ajnart
d6b6287d6d
- Add debug logging across Beszel integration, request handler, and tRPC router (auth, fetch, SSE, per-procedure entry/exit) gated behind LOG_LEVEL=debug - cached-request-handler: retry with backoff, isValid predicate to skip caching invalid data, in-flight dedup (single-flight per channel) to avoid thundering herd after cache invalidation - redis channel: set-then-publish so storage is always consistent even when pubsub publish fails - Beszel handlers: opt into fallbackToStaleOnError and retry so brief upstream hiccups don't throw away good cached data - beszel-system-stats: add refetchInterval matching each time period's cache TTL so historical charts refresh in the background - tRPC router: switch Promise.all -> Promise.allSettled for getSystems and getAlerts; getSystemStats returns an error object instead of throwing. Each result carries an optional error field so one failed integration no longer nukes the whole widget - Widgets: add explicit isPending loader, empty state for grid and stats, and a shared per-integration error indicator (tooltip with failed integration names). Alerts and table now only show their empty state after loading completes - Translation: add empty.noSystems key to beszelSystemGrid and beszelSystemStats Addresses #6030
50 lines
2.0 KiB
TypeScript
50 lines
2.0 KiB
TypeScript
import type { Duration } from "dayjs/plugin/duration";
|
|
|
|
import type { Modify } from "@homarr/common/types";
|
|
import type { Integration, IntegrationSecret } from "@homarr/db/schema";
|
|
import type { IntegrationKind } from "@homarr/definitions";
|
|
import { createIntegrationOptionsChannel } from "@homarr/redis";
|
|
|
|
import { createCachedRequestHandler } from "./cached-request-handler";
|
|
|
|
type IntegrationOfKind<TKind extends IntegrationKind> = Omit<Integration, "kind"> & {
|
|
kind: TKind;
|
|
decryptedSecrets: Modify<Pick<IntegrationSecret, "kind" | "value">, { value: string }>[];
|
|
externalUrl: string | null;
|
|
};
|
|
|
|
interface Options<TData, TKind extends IntegrationKind, TInput extends Record<string, unknown>> {
|
|
queryKey: string;
|
|
requestAsync: (integration: IntegrationOfKind<TKind>, input: TInput) => Promise<TData>;
|
|
cacheDuration: Duration;
|
|
cacheDurationForInput?: (input: TInput) => Duration | undefined;
|
|
fallbackToStaleOnError?: boolean;
|
|
retry?: { attempts?: number; delayMs?: number };
|
|
isValid?: (data: TData) => boolean;
|
|
}
|
|
|
|
export const createCachedIntegrationRequestHandler = <
|
|
TData,
|
|
TKind extends IntegrationKind,
|
|
TInput extends Record<string, unknown>,
|
|
>(
|
|
options: Options<TData, TKind, TInput>,
|
|
) => {
|
|
return {
|
|
handler: (integration: IntegrationOfKind<TKind>, itemOptions: TInput) =>
|
|
createCachedRequestHandler({
|
|
queryKey: options.queryKey,
|
|
requestAsync: async (input: { options: TInput; integration: IntegrationOfKind<TKind> }) => {
|
|
return await options.requestAsync(input.integration, input.options);
|
|
},
|
|
cacheDuration: options.cacheDurationForInput?.(itemOptions) ?? options.cacheDuration,
|
|
fallbackToStaleOnError: options.fallbackToStaleOnError,
|
|
retry: options.retry,
|
|
isValid: options.isValid,
|
|
createRedisChannel(input, handlerOptions) {
|
|
return createIntegrationOptionsChannel<TData>(input.integration.id, handlerOptions.queryKey, input.options);
|
|
},
|
|
}).handler({ options: itemOptions, integration }),
|
|
};
|
|
};
|