feat: simplify caching — TanStack Query as single source of truth (#6075)

.github/workflows/code-quality.yml

@@ -163,65 +163,3 @@ jobs:
         run: cp .env.example .env
       - name: Build
         run: pnpm turbo build --affected
-
-  memory-regression:
-    runs-on: ubuntu-latest
-    timeout-minutes: 15
-    steps:
-      - uses: actions/checkout@v6
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v4
-      - name: Build Docker image
-        uses: docker/build-push-action@v7
-        with:
-          platforms: linux/amd64
-          context: .
-          push: false
-          load: true
-          tags: homarr-memory-test
-          network: host
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-        env:
-          SKIP_ENV_VALIDATION: true
-      - name: Start container and measure memory
-        run: |
-          docker run -d --name homarr-mem-test -p 17575:7575 homarr-memory-test
-          # Wait for container to be healthy (up to 60s)
-          healthy=false
-          for i in $(seq 1 30); do
-            if curl -sf http://localhost:17575/api/health 2>/dev/null; then
-              echo "Container healthy after $((i * 2))s"
-              healthy=true
-              break
-            fi
-            sleep 2
-          done
-          if [ "$healthy" != "true" ]; then
-            echo "ERROR: Container never became healthy"
-            docker logs homarr-mem-test --tail 50
-            exit 1
-          fi
-          # Warm up: hit the dashboard page a few times
-          for i in $(seq 1 5); do
-            curl -sf http://localhost:17575/ > /dev/null 2>&1 || true
-            sleep 2
-          done
-          # Measure RSS after warmup
-          MEM_KB=$(docker stats --no-stream --format '{{.MemUsage}}' homarr-mem-test | sed 's| /.*||')
-          echo "Raw memory: $MEM_KB"
-          # Convert to numeric MB (handles GiB and MiB suffixes)
-          MEM_NUM=$(echo "$MEM_KB" | awk '{
-            if ($0 ~ /GiB/) { gsub(/GiB/,""); print $1 * 1024 }
-            else if ($0 ~ /MiB/) { gsub(/MiB/,""); print $1 }
-            else if ($0 ~ /KiB/) { gsub(/KiB/,""); print $1 / 1024 }
-            else { print $1 / 1048576 }
-          }')
-          echo "Memory usage: ${MEM_NUM} MB"
-          MAX_MB=700
-          if awk "BEGIN {exit !($MEM_NUM > $MAX_MB)}"; then
-            echo "ERROR: Memory usage ${MEM_NUM} MB exceeds ${MAX_MB} MB threshold"
-            docker logs homarr-mem-test --tail 50
-            exit 1
-          fi
-          echo "Memory check passed: ${MEM_NUM} MB <= ${MAX_MB} MB"

.gitignore

@@ -77,3 +77,4 @@ skills-lock.json
 # docusaurus
 apps/docs/.docusaurus
 apps/docs/build
+.pnpm-store

apps/nextjs/package.json

@@ -59,10 +59,11 @@
     "@modelcontextprotocol/sdk": "catalog:",
     "@scalar/api-reference-react": "catalog:",
     "@tabler/icons-react": "catalog:",
-    "@tanstack/query-persist-client-core": "catalog:",
+    "@tanstack/query-async-storage-persister": "catalog:",
     "@tanstack/react-query": "catalog:",
     "@tanstack/react-query-devtools": "catalog:",
     "@tanstack/react-query-next-experimental": "catalog:",
+    "@tanstack/react-query-persist-client": "catalog:",
     "@trpc/client": "catalog:",
     "@trpc/next": "catalog:",
     "@trpc/react-query": "catalog:",

apps/nextjs/src/app/[locale]/_client-providers/query-cache-persister.ts

@@ -1,49 +1,29 @@
-import type { AsyncStorage, PersistedQuery } from "@tanstack/query-persist-client-core";
-import { experimental_createQueryPersister } from "@tanstack/query-persist-client-core";
-import { parse, stringify } from "superjson";
+import { createAsyncStoragePersister } from "@tanstack/query-async-storage-persister";
 
 import { fetchApi } from "@homarr/api/client";
-import {
-  getActiveQueryCacheBoardId,
-  isPersistableWidgetQueryKey,
-  queryCacheStoragePrefix,
-} from "@homarr/api/query-cache";
+import { getActiveQueryCacheBoardId, queryCacheStoragePrefix } from "@homarr/api/query-cache";
 
 const queryCacheStorage = {
-  async getItem(_key) {
-    return null;
-  },
-  async setItem(key, value) {
+  getItem: (_key: string) => null as string | null,
+  async setItem(_key: string, value: string) {
     const boardId = getActiveQueryCacheBoardId();
     if (!boardId) return;
-
-    try {
-      await fetchApi.queryCache.setItem.mutate({ boardId, key, value });
-    } catch {
-      // Query persistence is best-effort; failed writes should not affect widget rendering.
-    }
+    await fetchApi.queryCache.setItem.mutate({ boardId, value }).catch((error) => {
+      console.warn("[query-cache] persist failed", error);
+    });
   },
-  async removeItem(key) {
+  async removeItem(_key: string) {
     const boardId = getActiveQueryCacheBoardId();
     if (!boardId) return;
-
-    try {
-      await fetchApi.queryCache.removeItem.mutate({ boardId, key });
-    } catch {
-      // Query persistence is best-effort; failed removals should not affect widget rendering.
-    }
+    await fetchApi.queryCache.removeItem.mutate({ boardId }).catch((error) => {
+      console.warn("[query-cache] remove failed", error);
+    });
   },
-} satisfies AsyncStorage<string>;
+};
 
 export const createWidgetQueryPersister = () =>
-  experimental_createQueryPersister<string>({
+  createAsyncStoragePersister({
     storage: typeof window === "undefined" ? undefined : queryCacheStorage,
-    maxAge: Number.POSITIVE_INFINITY,
-    prefix: queryCacheStoragePrefix,
-    refetchOnRestore: true,
-    serialize: (query) => stringify(query),
-    deserialize: (value) => parse<PersistedQuery>(value),
-    filters: {
-      predicate: (query) => isPersistableWidgetQueryKey(query.queryKey),
-    },
+    key: queryCacheStoragePrefix,
+    throttleTime: 2000,
   });

apps/nextjs/src/app/[locale]/_client-providers/trpc.tsx

@@ -2,9 +2,10 @@
 
 import type { PropsWithChildren } from "react";
 import { useState } from "react";
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { QueryClient } from "@tanstack/react-query";
 import { ReactQueryDevtools } from "@tanstack/react-query-devtools";
 import { ReactQueryStreamedHydration } from "@tanstack/react-query-next-experimental";
+import { PersistQueryClientProvider } from "@tanstack/react-query-persist-client";
 import {
   createWSClient,
   httpBatchStreamLink,
@@ -21,7 +22,12 @@ import { TRPCClientError } from "@trpc/client";
 
 import type { AppRouter } from "@homarr/api";
 import { clientApi } from "@homarr/api/client";
-import { queryCacheDefaultStaleTimeMs } from "@homarr/api/query-cache";
+import {
+  isPersistableWidgetQueryKey,
+  queryCacheDefaultGcTimeMs,
+  queryCacheDefaultRefetchIntervalMs,
+  queryCacheDefaultStaleTimeMs,
+} from "@homarr/api/query-cache";
 import { createHeadersCallbackForSource, getTrpcUrl } from "@homarr/api/shared";
 import { env } from "@homarr/common/env";
 import { showWarningNotification } from "@homarr/notifications";
@@ -29,7 +35,6 @@ import { showWarningNotification } from "@homarr/notifications";
 import { createWidgetQueryPersister } from "./query-cache-persister";
 
 const getWebSocketProtocol = () => {
-  // window is not defined on server side
   if (typeof window === "undefined") {
     return "ws";
   }
@@ -55,14 +60,16 @@ const wsClient = createWSClient({
 });
 
 export function TRPCReactProvider(props: PropsWithChildren) {
-  const [queryPersister] = useState(() => createWidgetQueryPersister());
-  const [queryClient] = useState(
-    () =>
-      new QueryClient({
+  const [persister] = useState(() => createWidgetQueryPersister());
+  const [queryClient] = useState(() => {
+    const client = new QueryClient({
       defaultOptions: {
         queries: {
-            persister: queryPersister.persisterFn,
           staleTime: queryCacheDefaultStaleTimeMs,
+          gcTime: queryCacheDefaultGcTimeMs,
+          refetchOnWindowFocus: false,
+          refetchOnReconnect: false,
+          retry: 3,
         },
         mutations: {
           onError(error) {
@@ -79,8 +86,10 @@ export function TRPCReactProvider(props: PropsWithChildren) {
           },
         },
       },
-      }),
-  );
+    });
+    client.setQueryDefaults([["widget"]], { refetchInterval: queryCacheDefaultRefetchIntervalMs });
+    return client;
+  });
 
   const [trpcClient] = useState(() => {
     return clientApi.createClient({
@@ -98,9 +107,6 @@ export function TRPCReactProvider(props: PropsWithChildren) {
           false: splitLink({
             condition: ({ input }) => isNonJsonSerializable(input),
             true: httpLink({
-              /**
-               * We don't want to transform the data here as we want to use form data
-               */
               transformer: {
                 serialize(object: unknown) {
                   return object;
@@ -115,7 +121,7 @@ export function TRPCReactProvider(props: PropsWithChildren) {
             false: httpBatchStreamLink({
               transformer: superjson,
               url: getTrpcUrl(),
-              maxURLLength: 2083, // Suggested by tRPC: https://trpc.io/docs/client/links/httpBatchLink#setting-a-maximum-url-length
+              maxURLLength: 2083,
               headers: createHeadersCallbackForSource("nextjs-react (json)"),
             }),
           }),
@@ -126,10 +132,20 @@ export function TRPCReactProvider(props: PropsWithChildren) {
 
   return (
     <clientApi.Provider client={trpcClient} queryClient={queryClient}>
-      <QueryClientProvider client={queryClient}>
+      <PersistQueryClientProvider
+        client={queryClient}
+        persistOptions={{
+          persister,
+          maxAge: queryCacheDefaultGcTimeMs,
+          dehydrateOptions: {
+            shouldDehydrateQuery: (query) =>
+              query.state.status === "success" && isPersistableWidgetQueryKey(query.queryKey),
+          },
+        }}
+      >
         <ReactQueryStreamedHydration transformer={superjson}>{props.children}</ReactQueryStreamedHydration>
         <ReactQueryDevtools initialIsOpen={false} />
-      </QueryClientProvider>
+      </PersistQueryClientProvider>
     </clientApi.Provider>
   );
 }

apps/nextjs/src/app/[locale]/boards/(content)/_creator.tsx

@@ -5,10 +5,8 @@ import { TRPCError } from "@trpc/server";
 // Placed here because gridstack styles are used for board content
 import "~/styles/gridstack.scss";
 
-import type { DehydratedState } from "@tanstack/react-query";
 import { dehydrate, HydrationBoundary } from "@tanstack/react-query";
-import { parse } from "superjson";
-
+import type { PersistedClient } from "@tanstack/react-query-persist-client";
 import { getQueryClient } from "@homarr/api/server";
 import { IntegrationProvider } from "@homarr/auth/client";
 import { auth } from "@homarr/auth/next";
@@ -17,7 +15,7 @@ import { isNullOrWhitespace } from "@homarr/common";
 import { createLogger } from "@homarr/core/infrastructure/logs";
 import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
 import type { WidgetKind } from "@homarr/definitions";
-import { getAllQueryCacheAsync } from "@homarr/redis";
+import { getQueryCacheAsync } from "@homarr/redis";
 import { getI18n } from "@homarr/translation/server";
 import { prefetchForKindAsync } from "@homarr/widgets/prefetch";
 
@@ -118,36 +116,17 @@ export const createBoardContentPage = <TParams extends Record<string, unknown>>(
   };
 };
 
-interface PersistedEntry {
-  state: { data: unknown; dataUpdatedAt: number; status: string };
-  queryKey: unknown[];
-  queryHash: string;
-}
-
 async function QueryCacheHydration({ userId, boardId }: { userId: string; boardId: string }) {
   try {
-    const entries = await getAllQueryCacheAsync(userId, boardId);
-    const queries: DehydratedState["queries"] = [];
+    const serialized = await getQueryCacheAsync(userId, boardId);
+    if (!serialized) return null;
 
-    for (const serialized of Object.values(entries)) {
-      try {
-        const persisted = parse<PersistedEntry>(serialized);
-        if (persisted.state.status !== "success") continue;
+    const persisted = JSON.parse(serialized) as PersistedClient;
+    if (!persisted?.clientState?.queries?.length) return null;
 
-        queries.push({
-          state: persisted.state as DehydratedState["queries"][number]["state"],
-          queryKey: persisted.queryKey,
-          queryHash: persisted.queryHash,
-        });
-      } catch {
-        // skip malformed entries
-      }
-    }
-
-    if (queries.length === 0) return null;
-
-    return <HydrationBoundary state={{ mutations: [], queries }} />;
-  } catch {
+    return <HydrationBoundary state={persisted.clientState} />;
+  } catch (error) {
+    logger.warn(new ErrorWithMetadata("Failed to hydrate query cache", { userId, boardId }, { cause: error }));
     return null;
   }
 }

apps/nextjs/src/app/[locale]/manage/tools/docker/docker-table.tsx

@@ -1,5 +1,6 @@
 "use client";
 
+import { useCallback } from "react";
 import { useRouter } from "next/navigation";
 import type { MantineColor } from "@mantine/core";
 import { ActionIcon, Avatar, Badge, Box, Button, Group, Menu, Text, Tooltip } from "@mantine/core";
@@ -156,29 +157,26 @@ interface DockerTableProps {
 export function DockerTable({ initialData }: DockerTableProps) {
   const t = useI18n();
   const tDocker = useScopedI18n("docker");
-  const { data, isFetching } = clientApi.docker.getContainers.useQuery(undefined, {
+  const { data, isFetching, refetch } = clientApi.docker.getContainers.useQuery(undefined, {
     initialData,
     refetchOnMount: false,
-    refetchOnWindowFocus: false,
-    refetchOnReconnect: false,
   });
   const relativeTime = useTimeAgo(data?.timestamp ?? new Date());
-  const utils = clientApi.useUtils();
-  const { mutate, isPending } = clientApi.docker.invalidate.useMutation({
-    async onSuccess() {
-      await utils.docker.getContainers.invalidate();
-      showSuccessNotification({
-        title: tDocker("action.refresh.notification.success.title"),
-        message: tDocker("action.refresh.notification.success.message"),
-      });
-    },
-    onError() {
+  const mutate = useCallback(() => {
+    void refetch().then((result) => {
+      if (result.isError) {
         showErrorNotification({
           title: tDocker("action.refresh.notification.error.title"),
           message: tDocker("action.refresh.notification.error.message"),
         });
-    },
+      } else {
+        showSuccessNotification({
+          title: tDocker("action.refresh.notification.success.title"),
+          message: tDocker("action.refresh.notification.success.message"),
         });
+      }
+    });
+  }, [refetch, tDocker]);
 
   const containers = data?.containers ?? [];
 
@@ -207,7 +205,12 @@ export function DockerTable({ initialData }: DockerTableProps) {
     mantineTableHeadCellProps: { style: { padding: "4px 8px" } },
     renderRowActions: ({ row }: { row: MRT_Row<DockerContainer> }) => <ContainerRowMenu container={row.original} />,
     renderTopToolbarCustomActions: () => (
-      <Button variant="default" rightSection={<IconRefresh size="1rem" />} onClick={() => mutate()} loading={isPending}>
+      <Button
+        variant="default"
+        rightSection={<IconRefresh size="1rem" />}
+        onClick={() => mutate()}
+        loading={isFetching}
+      >
         {tDocker("action.refresh.label")}
       </Button>
     ),

apps/nextjs/src/components/board/items/item-content.tsx

@@ -2,7 +2,7 @@ import type { MutableRefObject } from "react";
 import { useRef } from "react";
 import { Badge, Card } from "@mantine/core";
 import { useElementSize } from "@mantine/hooks";
-import { QueryErrorResetBoundary } from "@tanstack/react-query";
+import { QueryErrorResetBoundary, useQueryClient } from "@tanstack/react-query";
 import combineClasses from "clsx";
 import { NoIntegrationSelectedError } from "@homarr/widgets/errors/classes";
 import { ErrorBoundary } from "react-error-boundary";
@@ -105,12 +105,16 @@ const InnerContent = ({ item, ...dimensions }: InnerContentProps) => {
     updateItemOptions({ itemId: item.id, newOptions });
   const widgetSupportsIntegrations =
     "supportedIntegrations" in definition && definition.supportedIntegrations.length >= 1;
+  const queryClient = useQueryClient();
 
   return (
     <QueryErrorResetBoundary>
       {({ reset }) => (
         <ErrorBoundary
-          onReset={reset}
+          onReset={() => {
+            void queryClient.invalidateQueries({ queryKey: [["widget"]] });
+            reset();
+          }}
           fallbackRender={({ resetErrorBoundary, error }) => (
             <>
               <BoardItemMenu offset={4} item={newItem} resetErrorBoundary={resetErrorBoundary} />

apps/nextjs/src/components/board/items/widget-context-menu.tsx

@@ -1,9 +1,11 @@
 "use client";
 
 import type { MutableRefObject, ReactNode } from "react";
-import { useCallback, useMemo } from "react";
-import { Group, Menu, Switch } from "@mantine/core";
-import { IconCopy, IconLayoutKanban, IconSettings, IconTrash } from "@tabler/icons-react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Group, Menu, Switch, Text } from "@mantine/core";
+import { IconCopy, IconLayoutKanban, IconRefresh, IconSettings, IconTrash } from "@tabler/icons-react";
+import type { QueryClient } from "@tanstack/react-query";
+import { useQueryClient } from "@tanstack/react-query";
 
 import { clientApi } from "@homarr/api/client";
 import { useSession } from "@homarr/auth/client";
@@ -45,6 +47,12 @@ export const WidgetContextMenu = ({ item, widgetStateRef, children }: WidgetCont
   const { mutate: saveBoard } = clientApi.board.saveBoard.useMutation();
   const currentDefinition = useMemo(() => widgetImports[item.kind].definition, [item.kind]);
   const { gridstack } = useSectionContext().refs;
+  const queryClient = useQueryClient();
+
+  const widgetQueryKey = useMemo(() => [["widget", item.kind]], [item.kind]);
+  const handleRefetch = useCallback(() => {
+    void queryClient.invalidateQueries({ queryKey: widgetQueryKey });
+  }, [queryClient, widgetQueryKey]);
 
   const options = useMemo(
     () => reduceWidgetOptionsWithDefaultValues(item.kind, settings, item.options) as Record<string, unknown>,
@@ -214,7 +222,15 @@ export const WidgetContextMenu = ({ item, widgetStateRef, children }: WidgetCont
         )}
 
         <>
-          {!isEditMode && (toggleOptions.length > 0 || visibleWidgetActions.length > 0) && <Menu.Divider />}
+          {(toggleOptions.length > 0 || visibleWidgetActions.length > 0 || isEditMode) && <Menu.Divider />}
+          <Menu.Item closeMenuOnClick leftSection={<IconRefresh size={16} />} onClick={handleRefetch}>
+            <Group justify="space-between" wrap="nowrap">
+              {tMenu("refresh")}
+              <Text size="xs" c="dimmed">
+                <WidgetCacheAge queryClient={queryClient} queryKey={widgetQueryKey} />
+              </Text>
+            </Group>
+          </Menu.Item>
           <Menu.Item
             closeMenuOnClick
             leftSection={<IconSettings size={16} />}
@@ -248,3 +264,24 @@ export const WidgetContextMenu = ({ item, widgetStateRef, children }: WidgetCont
     </Menu>
   );
 };
+
+const WidgetCacheAge = ({ queryClient, queryKey }: { queryClient: QueryClient; queryKey: unknown[] }) => {
+  const [, setTick] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => setTick((n) => n + 1), 1000);
+    return () => clearInterval(id);
+  }, []);
+
+  const timestamps = queryClient
+    .getQueryCache()
+    .findAll({ queryKey })
+    .map((q) => q.state.dataUpdatedAt)
+    .filter(Boolean);
+  if (timestamps.length === 0) return null;
+
+  const oldest = Math.min(...timestamps);
+  const seconds = Math.floor((Date.now() - oldest) / 1000);
+  if (seconds < 5) return "just now";
+  if (seconds < 60) return `${seconds}s ago`;
+  return `${Math.floor(seconds / 60)}m ago`;
+};

apps/tasks/src/on-start/index.ts

@@ -1,7 +1,7 @@
-import { invalidateUpdateCheckerCacheAsync } from "./invalidate-update-checker-cache";
 import { cleanupSessionsAsync } from "./session-cleanup";
+import { warmUpdateCheckerAsync } from "./warm-update-checker";
 
 export async function onStartAsync() {
   await cleanupSessionsAsync();
-  await invalidateUpdateCheckerCacheAsync();
+  await warmUpdateCheckerAsync();
 }

apps/tasks/src/on-start/invalidate-update-checker-cache.ts

@@ -1,18 +0,0 @@
-import { createLogger } from "@homarr/core/infrastructure/logs";
-import { updateCheckerRequestHandler } from "@homarr/request-handler/update-checker";
-
-const logger = createLogger({ module: "invalidateUpdateCheckerCache" });
-
-/**
- * Invalidates the update checker cache on startup to ensure fresh data.
- * It is important as we want to avoid showing pending updates after the update to latest version.
- */
-export async function invalidateUpdateCheckerCacheAsync() {
-  try {
-    const handler = updateCheckerRequestHandler.handler({});
-    await handler.invalidateAsync();
-    logger.debug("Update checker cache invalidated");
-  } catch (error) {
-    logger.error(new Error("Failed to invalidate update checker cache", { cause: error }));
-  }
-}

apps/tasks/src/on-start/warm-update-checker.ts

@@ -0,0 +1,14 @@
+import { createLogger } from "@homarr/core/infrastructure/logs";
+import { updateCheckerRequestHandler } from "@homarr/request-handler/update-checker";
+
+const logger = createLogger({ module: "warmUpdateChecker" });
+
+export async function warmUpdateCheckerAsync() {
+  try {
+    const handler = updateCheckerRequestHandler.handler({});
+    await handler.getDataAsync();
+    logger.debug("Update checker warmed");
+  } catch (error) {
+    logger.error(new Error("Failed to warm update checker", { cause: error }));
+  }
+}

mise.toml

@@ -0,0 +1,2 @@
+[tools]
+node = "24.18.0"

packages/analytics/src/send-server-analytics.ts

@@ -36,8 +36,6 @@ const logger = createLogger({ module: "analytics" });
 
 type AnalyticsResult = "sent" | "disabled" | "failed";
 
-// ponytail: no DB-level lock; concurrent calls may both generate an ID, but the last write wins
-// and the ID stabilizes after the first successful run. Upgrade path: use DB upsert with WHERE instanceId IS NULL.
 const getOrCreateInstanceId = async (
   analyticsSettings: Awaited<ReturnType<typeof getServerSettingByKeyAsync<"analytics">>>,
 ): Promise<string> => {

packages/api/src/query-cache.ts

@@ -1,7 +1,8 @@
 import type { QueryKey } from "@tanstack/react-query";
 
-export const queryCacheRetentionMs = 1000 * 60 * 60 * 24;
-export const queryCacheDefaultStaleTimeMs = 1000 * 60 * 5;
+export const queryCacheDefaultStaleTimeMs = 0;
+export const queryCacheDefaultRefetchIntervalMs = 30_000;
+export const queryCacheDefaultGcTimeMs = 1000 * 60 * 60 * 24;
 export const queryCacheMaxValueBytes = 1024 * 1024;
 export const queryCacheStoragePrefix = "homarr-widget-query";
 

packages/api/src/router/docker/docker-router.ts

@@ -25,9 +25,7 @@ export const dockerRouter = createTRPCRouter({
     .concat(dockerMiddleware())
     .query(async () => {
       const innerHandler = dockerContainersRequestHandler.handler({});
-      const result = await innerHandler.getCachedOrUpdatedDataAsync({
-        forceUpdate: false,
-      });
+      const result = await innerHandler.getDataAsync();
 
       const { data, timestamp } = result;
 
@@ -36,26 +34,6 @@ export const dockerRouter = createTRPCRouter({
         timestamp,
       };
     }),
-  subscribeContainers: permissionRequiredProcedure
-    .requiresPermission("admin")
-    .concat(dockerMiddleware())
-    .subscription(() => {
-      return observable<DockerContainer[]>((emit) => {
-        const innerHandler = dockerContainersRequestHandler.handler({});
-        const unsubscribe = innerHandler.subscribe((data) => {
-          emit.next(data);
-        });
-
-        return unsubscribe;
-      });
-    }),
-  invalidate: permissionRequiredProcedure
-    .requiresPermission("admin")
-    .concat(dockerMiddleware())
-    .mutation(async () => {
-      const innerHandler = dockerContainersRequestHandler.handler({});
-      await innerHandler.invalidateAsync();
-    }),
   startAll: permissionRequiredProcedure
     .requiresPermission("admin")
     .meta({
@@ -73,9 +51,6 @@ export const dockerRouter = createTRPCRouter({
           await container.start();
         }),
       );
-
-      const innerHandler = dockerContainersRequestHandler.handler({});
-      await innerHandler.invalidateAsync();
     }),
   stopAll: permissionRequiredProcedure
     .requiresPermission("admin")
@@ -94,9 +69,6 @@ export const dockerRouter = createTRPCRouter({
           await container.stop();
         }),
       );
-
-      const innerHandler = dockerContainersRequestHandler.handler({});
-      await innerHandler.invalidateAsync();
     }),
   restartAll: permissionRequiredProcedure
     .requiresPermission("admin")
@@ -116,9 +88,6 @@ export const dockerRouter = createTRPCRouter({
           await container.restart();
         }),
       );
-
-      const innerHandler = dockerContainersRequestHandler.handler({});
-      await innerHandler.invalidateAsync();
     }),
   removeAll: permissionRequiredProcedure
     .requiresPermission("admin")
@@ -138,9 +107,6 @@ export const dockerRouter = createTRPCRouter({
           await container.remove();
         }),
       );
-
-      const innerHandler = dockerContainersRequestHandler.handler({});
-      await innerHandler.invalidateAsync();
     }),
   logs: permissionRequiredProcedure
     .requiresPermission("admin")

packages/api/src/router/icons.ts

@@ -30,8 +30,6 @@ export const iconsRouter = createTRPCRouter({
               columns: { id: true, name: true, url: true },
               where: whereCondition,
               orderBy: (table, { asc, sql }) => {
-                // ponytail: SVG first, then alphabetical; with a search term,
-                // prepend a relevance tier (exact > prefix > substring).
                 const svgFirst = sql`CASE WHEN ${table.name} LIKE '%.svg' THEN 0 ELSE 1 END`;
                 const nameAsc = asc(table.name);
                 if (term.length === 0) {

packages/api/src/router/query-cache.ts

@@ -2,53 +2,41 @@ import { z } from "zod/v4";
 
 import { eq } from "@homarr/db";
 import { boards } from "@homarr/db/schema";
-import { createQueryCacheChannel } from "@homarr/redis";
+import { removeQueryCacheAsync, setQueryCacheAsync } from "@homarr/redis";
 
-import { queryCacheMaxValueBytes, queryCacheRetentionMs } from "../query-cache";
+import { queryCacheDefaultGcTimeMs, queryCacheMaxValueBytes } from "../query-cache";
 import { createTRPCRouter, publicProcedure } from "../trpc";
 import { throwIfActionForbiddenAsync } from "./board/board-access";
 
-const queryCacheKeyInput = z.object({
+const queryCacheBoardInput = z.object({
   boardId: z.string().min(1),
-  key: z.string().min(1).max(4096),
 });
 
-const queryCacheSetInput = queryCacheKeyInput.extend({
+const queryCacheSetInput = queryCacheBoardInput.extend({
   value: z.string().max(queryCacheMaxValueBytes * 2),
 });
 
-const createChannel = (input: z.infer<typeof queryCacheKeyInput>, userId: string) =>
-  createQueryCacheChannel({
-    userId,
-    boardId: input.boardId,
-    key: input.key,
-    ttlMs: queryCacheRetentionMs,
-    maxValueBytes: queryCacheMaxValueBytes,
-  });
-
 const validateBoardAccessAsync = async (ctx: Parameters<typeof throwIfActionForbiddenAsync>[0], boardId: string) => {
   await throwIfActionForbiddenAsync(ctx, eq(boards.id, boardId), "view");
 };
 
 export const queryCacheRouter = createTRPCRouter({
-  getItem: publicProcedure.input(queryCacheKeyInput).query(async ({ ctx, input }) => {
-    await validateBoardAccessAsync(ctx, input.boardId);
-
-    const channel = createChannel(input, ctx.session?.user.id ?? "anonymous");
-    return await channel.getAsync();
-  }),
   setItem: publicProcedure.input(queryCacheSetInput).mutation(async ({ ctx, input }) => {
     await validateBoardAccessAsync(ctx, input.boardId);
-
-    const channel = createChannel(input, ctx.session?.user.id ?? "anonymous");
+    const userId = ctx.session?.user.id ?? "anonymous";
     return {
-      stored: await channel.setAsync(input.value),
+      stored: await setQueryCacheAsync(
+        userId,
+        input.boardId,
+        input.value,
+        queryCacheDefaultGcTimeMs,
+        queryCacheMaxValueBytes,
+      ),
     };
   }),
-  removeItem: publicProcedure.input(queryCacheKeyInput).mutation(async ({ ctx, input }) => {
+  removeItem: publicProcedure.input(queryCacheBoardInput).mutation(async ({ ctx, input }) => {
     await validateBoardAccessAsync(ctx, input.boardId);
-
-    const channel = createChannel(input, ctx.session?.user.id ?? "anonymous");
-    await channel.removeAsync();
+    const userId = ctx.session?.user.id ?? "anonymous";
+    await removeQueryCacheAsync(userId, input.boardId);
   }),
 });

packages/api/src/router/test/docker/docker-router.spec.ts

@@ -23,28 +23,12 @@ vi.mock("@homarr/request-handler/docker", () => ({
   },
   dockerContainersRequestHandler: {
     handler: () => ({
-      getCachedOrUpdatedDataAsync: async () => {
-        return await Promise.resolve({ containers: [] });
-      },
-      invalidateAsync: async () => {
-        return await Promise.resolve();
+      getDataAsync: async () => {
+        return await Promise.resolve({ data: [], timestamp: new Date() });
       },
     }),
   },
 }));
-vi.mock("@homarr/redis", () => ({
-  createCacheChannel: () => ({
-    // eslint-disable-next-line @typescript-eslint/require-await
-    consumeAsync: async () => ({
-      timestamp: new Date().toISOString(),
-      data: { containers: [] },
-    }),
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    invalidateAsync: async () => {},
-  }),
-  createWidgetOptionsChannel: () => ({}),
-}));
-
 vi.mock("@homarr/docker/env", () => ({
   env: {
     ENABLE_DOCKER: true,
@@ -67,12 +51,10 @@ const validInputs: {
   [key in (typeof procedureKeys)[number]]: RouterInputs["docker"][key];
 } = {
   getContainers: undefined,
-  subscribeContainers: undefined,
   startAll: { ids: ["1"] },
   stopAll: { ids: ["1"] },
   restartAll: { ids: ["1"] },
   removeAll: { ids: ["1"] },
-  invalidate: undefined,
   logs: { id: "1", tail: 200 },
   subscribeLogs: { id: "1", tail: 200 },
 };

packages/api/src/router/update-checker.ts

@@ -9,7 +9,7 @@ export const updateCheckerRouter = createTRPCRouter({
   getAvailableUpdates: permissionRequiredProcedure.requiresPermission("admin").query(async () => {
     try {
       const handler = updateCheckerRequestHandler.handler({});
-      const data = await handler.getCachedOrUpdatedDataAsync({});
+      const data = await handler.getDataAsync();
       return data.data.availableUpdates;
     } catch (error) {
       logger.error(new Error("Failed to get available updates", { cause: error }));

packages/api/src/router/widgets/anchor-notes.ts

@@ -45,9 +45,7 @@ export const anchorNotesRouter = createTRPCRouter({
     .query(async ({ ctx, input }) => {
       const handler = anchorNotesListRequestHandler.handler(ctx.integration, { ...input, limit: input.limit ?? 50 });
 
-      const { data } = await handler.getCachedOrUpdatedDataAsync({
-        forceUpdate: false,
-      });
+      const { data } = await handler.getDataAsync();
 
       return data;
     }),
@@ -57,9 +55,7 @@ export const anchorNotesRouter = createTRPCRouter({
     .query(async ({ ctx, input }) => {
       const handler = anchorNoteRequestHandler.handler(ctx.integration, { noteId: input.noteId });
 
-      const { data } = await handler.getCachedOrUpdatedDataAsync({
-        forceUpdate: false,
-      });
+      const { data } = await handler.getDataAsync();
 
       return data;
     }),
@@ -79,9 +75,6 @@ export const anchorNotesRouter = createTRPCRouter({
           ...(normalizedContent !== undefined ? { content: normalizedContent } : {}),
         });
 
-        const noteHandler = anchorNoteRequestHandler.handler(ctx.integration, { noteId: input.noteId });
-        await noteHandler.invalidateAsync();
-
         return updatedNote;
       } catch (error) {
         if (error instanceof ResponseError && error.statusCode === 400) {

packages/api/src/router/widgets/app.ts

@@ -1,10 +1,8 @@
 import { TRPCError } from "@trpc/server";
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
 import { getServerSettingByKeyAsync } from "@homarr/db/queries";
 import { sendPingRequestAsync } from "@homarr/ping";
-import { pingChannel, pingUrlChannel } from "@homarr/redis";
 
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 import { AppRepository } from "../app";
@@ -45,55 +43,4 @@ export const appRouter = createTRPCRouter({
       ...pingResult,
     };
   }),
-  updatedPing: publicProcedure
-    .input(
-      z.object({
-        id: z.string(),
-      }),
-    )
-    .subscription(async ({ ctx, input }) => {
-      const boardSettings = await getServerSettingByKeyAsync(ctx.db, "board");
-      if (boardSettings.forceDisableStatus) {
-        throw new TRPCError({
-          code: "FORBIDDEN",
-          message: "Ping functionality is disabled by server settings",
-        });
-      }
-
-      const repository = new AppRepository(ctx.db, ctx.session?.user ?? null);
-      const app = await repository.getByIdAsync(input.id);
-
-      if (!app) {
-        throw new TRPCError({
-          code: "NOT_FOUND",
-          message: "App not found",
-        });
-      }
-
-      const pingUrl = app.pingUrl ?? app.href;
-
-      if (!pingUrl) {
-        throw new TRPCError({
-          code: "CONFLICT",
-          message: "No URL to ping configured for this app",
-        });
-      }
-
-      await pingUrlChannel.addAsync(pingUrl);
-
-      return observable<{ url: string; statusCode: number; durationMs: number } | { url: string; error: string }>(
-        (emit) => {
-          const unsubscribe = pingChannel.subscribe((message) => {
-            // Only emit if same url
-            if (message.url !== pingUrl) return;
-            emit.next(message);
-          });
-
-          return () => {
-            unsubscribe();
-            void pingUrlChannel.removeAsync(pingUrl);
-          };
-        },
-      );
-    }),
 });

packages/api/src/router/widgets/archive-team-warrior.ts

@@ -1,6 +1,3 @@
-import { observable } from "@trpc/server/observable";
-
-import type { ArchiveTeamWarriorStatus } from "@homarr/integrations";
 import { archiveTeamWarriorRequestHandler } from "@homarr/request-handler/archive-team-warrior";
 
 import { createOneIntegrationMiddleware } from "../../middlewares/integration";
@@ -11,29 +8,11 @@ export const archiveTeamWarriorRouter = createTRPCRouter({
     .concat(createOneIntegrationMiddleware("query", "archiveTeamWarrior"))
     .query(async ({ ctx }) => {
       const handler = archiveTeamWarriorRequestHandler.handler(ctx.integration, {});
-      const { data, timestamp } = await handler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+      const { data, timestamp } = await handler.getDataAsync();
 
       return {
         status: data,
         updatedAt: timestamp,
       };
     }),
-
-  subscribeStatus: publicProcedure
-    .concat(createOneIntegrationMiddleware("query", "archiveTeamWarrior"))
-    .subscription(({ ctx }) => {
-      return observable<{ status: ArchiveTeamWarriorStatus; updatedAt: Date }>((emit) => {
-        const handler = archiveTeamWarriorRequestHandler.handler(ctx.integration, {});
-        const unsubscribe = handler.subscribe((status) => {
-          emit.next({
-            status,
-            updatedAt: new Date(),
-          });
-        });
-
-        return () => {
-          unsubscribe();
-        };
-      });
-    }),
 });

packages/api/src/router/widgets/audio-stats.ts

@@ -13,14 +13,14 @@ export const audioStatsRouter = createTRPCRouter({
       const fetchByKind = {
         navidrome: async () => {
           const handler = navidromeRequestHandler.handler({ ...ctx.integration, kind: "navidrome" as const }, {});
-          return (await handler.getCachedOrUpdatedDataAsync({ forceUpdate: false })).data;
+          return (await handler.getDataAsync()).data;
         },
         audiobookshelf: async () => {
           const handler = audiobookshelfRequestHandler.handler(
             { ...ctx.integration, kind: "audiobookshelf" as const },
             {},
           );
-          return (await handler.getCachedOrUpdatedDataAsync({ forceUpdate: false })).data;
+          return (await handler.getDataAsync()).data;
         },
       } as const;
 

packages/api/src/router/widgets/beszel.ts

@@ -1,16 +1,12 @@
 import { TRPCError } from "@trpc/server";
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
 import { createLogger } from "@homarr/core/infrastructure/logs";
-import { createIntegrationAsync } from "@homarr/integrations";
-import type { BeszelContainerStatsRecord, BeszelSystemStatsRecord } from "@homarr/integrations/types";
 import {
   beszelAlertsRequestHandler,
   beszelStatsRequestHandler,
   beszelSystemsRequestHandler,
 } from "@homarr/request-handler/beszel";
-import type { BeszelAlertsData, BeszelSystemRow } from "@homarr/request-handler/beszel";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
@@ -33,9 +29,7 @@ export const beszelRouter = createTRPCRouter({
       const settled = await Promise.allSettled(
         ctx.integrations.map(async (integration) => {
           const innerHandler = beszelSystemsRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({
-            forceUpdate: false,
-          });
+          const { data, timestamp } = await innerHandler.getDataAsync();
           return {
             integrationId: integration.id,
             integrationName: integration.name,
@@ -71,30 +65,6 @@ export const beszelRouter = createTRPCRouter({
       return results;
     }),
 
-  subscribeSystems: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", "beszel", "mock"))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integrationId: string;
-        systems: BeszelSystemRow[];
-        timestamp: Date;
-      }>((emit) => {
-        const unsubscribes = ctx.integrations.map((integration) => {
-          const innerHandler = beszelSystemsRequestHandler.handler(integration, {});
-          return innerHandler.subscribe((systems) => {
-            emit.next({
-              integrationId: integration.id,
-              systems,
-              timestamp: new Date(),
-            });
-          });
-        });
-        return () => {
-          unsubscribes.forEach((fn) => fn());
-        };
-      });
-    }),
-
   getAlerts: publicProcedure
     .meta({
       mcp: {
@@ -125,14 +95,18 @@ export const beszelRouter = createTRPCRouter({
             maxHistoryItems: input.maxHistoryItems,
           });
           const systemsHandler = beszelSystemsRequestHandler.handler(integration, {});
-          const [alertsResult, systemsResult] = await Promise.all([
-            alertsHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false }),
-            systemsHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false }),
+          const [alertsSettled, systemsSettled] = await Promise.allSettled([
+            alertsHandler.getDataAsync(),
+            systemsHandler.getDataAsync(),
           ]);
+          if (alertsSettled.status === "rejected") throw alertsSettled.reason;
+          const alertsResult = alertsSettled.value;
           const systemNameMap: Record<string, string> = {};
-          for (const system of systemsResult.data) {
+          if (systemsSettled.status === "fulfilled") {
+            for (const system of systemsSettled.value.data) {
               systemNameMap[system.id] = system.name;
             }
+          }
           return {
             integrationId: integration.id,
             integrationName: integration.name,
@@ -170,39 +144,6 @@ export const beszelRouter = createTRPCRouter({
       return results;
     }),
 
-  subscribeAlerts: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", "beszel", "mock"))
-    .input(
-      z.object({
-        includeHistory: z.boolean().default(true),
-        maxHistoryItems: z.number().min(1).max(100).default(10),
-      }),
-    )
-    .subscription(({ ctx, input }) => {
-      return observable<{
-        integrationId: string;
-        alerts: BeszelAlertsData;
-        timestamp: Date;
-      }>((emit) => {
-        const unsubscribes = ctx.integrations.map((integration) => {
-          const innerHandler = beszelAlertsRequestHandler.handler(integration, {
-            includeHistory: input.includeHistory,
-            maxHistoryItems: input.maxHistoryItems,
-          });
-          return innerHandler.subscribe((data) => {
-            emit.next({
-              integrationId: integration.id,
-              alerts: data,
-              timestamp: new Date(),
-            });
-          });
-        });
-        return () => {
-          unsubscribes.forEach((fn) => fn());
-        };
-      });
-    }),
-
   getSystemStats: publicProcedure
     .meta({
       mcp: {
@@ -237,7 +178,7 @@ export const beszelRouter = createTRPCRouter({
           timePeriod: input.timePeriod,
           includeDocker: input.includeDocker,
         });
-        const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
         logger.debug("getSystemStats completed", {
           userId: ctx.session?.user?.id,
           integrationId: integration.id,
@@ -260,61 +201,4 @@ export const beszelRouter = createTRPCRouter({
         };
       }
     }),
-
-  subscribeSystemStats: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", "beszel", "mock"))
-    .input(
-      z.object({
-        systemId: z.string(),
-      }),
-    )
-    .subscription(({ ctx, input }) => {
-      return observable<{
-        stats: BeszelSystemStatsRecord;
-        containerStats: BeszelContainerStatsRecord | null;
-      }>((emit) => {
-        const integration = ctx.integrations[0];
-        if (!integration) {
-          emit.error(new Error("No Beszel integration configured"));
-          return () => {};
-        }
-        logger.debug("subscribeSystemStats opened", {
-          userId: ctx.session?.user?.id,
-          integrationId: integration.id,
-          systemId: input.systemId,
-        });
-
-        const abortController = new AbortController();
-
-        void (async () => {
-          try {
-            const instance = await createIntegrationAsync(integration);
-            await instance.subscribeRealtimeMetrics(input.systemId, (data) => emit.next(data), abortController.signal);
-          } catch (error) {
-            if (!abortController.signal.aborted) {
-              logger.warn("subscribeSystemStats error", {
-                userId: ctx.session?.user?.id,
-                integrationId: integration.id,
-                systemId: input.systemId,
-                error,
-              });
-              if (error instanceof Error) {
-                emit.error(error);
-              } else {
-                emit.error(new Error(String(error)));
-              }
-            }
-          }
-        })();
-
-        return () => {
-          abortController.abort();
-          logger.debug("subscribeSystemStats closed", {
-            userId: ctx.session?.user?.id,
-            integrationId: integration.id,
-            systemId: input.systemId,
-          });
-        };
-      });
-    }),
 });

packages/api/src/router/widgets/calendar.ts

@@ -1,13 +1,8 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
-import type { Modify } from "@homarr/common/types";
 import { createLogger } from "@homarr/core/infrastructure/logs";
 import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
-import type { Integration } from "@homarr/db/schema";
-import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { CalendarEvent } from "@homarr/integrations/types";
 import { radarrReleaseTypes } from "@homarr/integrations/types";
 import { calendarMonthRequestHandler } from "@homarr/request-handler/calendar";
 
@@ -39,9 +34,7 @@ export const calendarRouter = createTRPCRouter({
         ctx.integrations.map(async (integration) => {
           const { integrationIds: _integrationIds, ...handlerInput } = input;
           const innerHandler = calendarMonthRequestHandler.handler(integration, handlerInput);
-          const { data } = await innerHandler.getCachedOrUpdatedDataAsync({
-            forceUpdate: false,
-          });
+          const { data } = await innerHandler.getDataAsync();
 
           return {
             events: data,
@@ -72,39 +65,4 @@ export const calendarRouter = createTRPCRouter({
         return [];
       });
     }),
-  subscribeToEvents: publicProcedure
-    .input(
-      z.object({
-        year: z.number(),
-        month: z.number(),
-        releaseType: z.array(z.enum(radarrReleaseTypes)),
-        showUnmonitored: z.boolean(),
-      }),
-    )
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("calendar")))
-    .subscription(({ ctx, input }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"calendar"> }>;
-        events: CalendarEvent[];
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const { integrationIds: _integrationIds, ...handlerInput } = input;
-          const innerHandler = calendarMonthRequestHandler.handler(integrationWithSecrets, handlerInput);
-          const unsubscribe = innerHandler.subscribe((events) => {
-            emit.next({
-              integration,
-              events,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
-      });
-    }),
 });

packages/api/src/router/widgets/coolify.ts

@@ -1,19 +1,16 @@
-import { observable } from "@trpc/server/observable";
-
-import type { CoolifyInstanceInfo } from "@homarr/integrations/types";
 import { coolifyRequestHandler } from "@homarr/request-handler/coolify";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const coolifyRouter = createTRPCRouter({
   getInstancesInfo: publicProcedure
     .concat(createManyIntegrationMiddleware("query", "coolify"))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = coolifyRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
           integrationId: integration.id,
@@ -22,29 +19,6 @@ export const coolifyRouter = createTRPCRouter({
           instanceInfo: data,
           updatedAt: timestamp,
         };
-        }),
-      );
-
-      return results;
-    }),
-  subscribeInstancesInfo: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", "coolify"))
-    .subscription(({ ctx }) => {
-      return observable<{ integrationId: string; instanceInfo: CoolifyInstanceInfo; timestamp: Date }>((emit) => {
-        const unsubscribes = ctx.integrations.map((integration) => {
-          const innerHandler = coolifyRequestHandler.handler(integration, {});
-          return innerHandler.subscribe((instanceInfo) => {
-            emit.next({
-              integrationId: integration.id,
-              instanceInfo,
-              timestamp: new Date(),
-            });
-          });
-        });
-
-        return () => {
-          unsubscribes.forEach((unsubscribe) => unsubscribe());
-        };
       });
     }),
 });

packages/api/src/router/widgets/dns-hole.ts

@@ -1,15 +1,11 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
-import type { Modify } from "@homarr/common/types";
-import type { Integration } from "@homarr/db/schema";
-import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
-import type { DnsHoleSummary } from "@homarr/integrations/types";
 import { dnsHoleRequestHandler } from "@homarr/request-handler/dns-hole";
 
 import { createManyIntegrationMiddleware, createOneIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, protectedProcedure, publicProcedure } from "../../trpc";
 
 export const dnsHoleRouter = createTRPCRouter({
@@ -23,51 +19,12 @@ export const dnsHoleRouter = createTRPCRouter({
     })
     .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("dnsHole")))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = dnsHoleRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({
-            forceUpdate: false,
-          });
-
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
+        const { data, timestamp } = await dnsHoleRequestHandler.handler(integration, {}).getDataAsync();
         return {
-            integration: {
-              id: integration.id,
-              name: integration.name,
-              kind: integration.kind,
-              updatedAt: timestamp,
-            },
+          integration: { id: integration.id, name: integration.name, kind: integration.kind, updatedAt: timestamp },
           summary: data,
         };
-        }),
-      );
-      return results;
-    }),
-
-  subscribeToSummary: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("dnsHole")))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"dnsHole"> }>;
-        summary: DnsHoleSummary;
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = dnsHoleRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((summary) => {
-            emit.next({
-              integration,
-              summary,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
       });
     }),
 
@@ -83,12 +40,6 @@ export const dnsHoleRouter = createTRPCRouter({
     .mutation(async ({ ctx: { integration } }) => {
       const client = await createIntegrationAsync(integration);
       await client.enableAsync();
-
-      const innerHandler = dnsHoleRequestHandler.handler(integration, {});
-      // We need to wait for the integration to be enabled before invalidating the cache
-      await new Promise<void>((resolve) => {
-        setTimeout(() => void innerHandler.invalidateAsync().then(resolve), 1000);
-      });
     }),
 
   disable: protectedProcedure
@@ -108,11 +59,5 @@ export const dnsHoleRouter = createTRPCRouter({
     .mutation(async ({ ctx: { integration }, input }) => {
       const client = await createIntegrationAsync(integration);
       await client.disableAsync(input.duration);
-
-      const innerHandler = dnsHoleRequestHandler.handler(integration, {});
-      // We need to wait for the integration to be disabled before invalidating the cache
-      await new Promise<void>((resolve) => {
-        setTimeout(() => void innerHandler.invalidateAsync().then(resolve), 1000);
-      });
     }),
 });

packages/api/src/router/widgets/downloads.ts

@@ -1,16 +1,12 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
-import type { Modify } from "@homarr/common/types";
-import type { Integration } from "@homarr/db/schema";
-import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { DownloadClientJobsAndStatus } from "@homarr/integrations";
 import { createIntegrationAsync, downloadClientItemSchema } from "@homarr/integrations";
 import { downloadClientRequestHandler } from "@homarr/request-handler/downloads";
 
 import type { IntegrationAction } from "../../middlewares/integration";
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, protectedProcedure, publicProcedure } from "../../trpc";
 
 const createDownloadClientIntegrationMiddleware = (action: IntegrationAction) =>
@@ -28,53 +24,13 @@ export const downloadsRouter = createTRPCRouter({
     .concat(createDownloadClientIntegrationMiddleware("query"))
     .input(z.object({ limitPerIntegration: z.number().default(50) }))
     .query(async ({ ctx, input }) => {
-      return await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = downloadClientRequestHandler.handler(integration, { limit: input.limitPerIntegration });
-
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({
-            forceUpdate: false,
-          });
-
+        const { data, timestamp } = await innerHandler.getDataAsync();
         return {
-            integration: {
-              id: integration.id,
-              name: integration.name,
-              kind: integration.kind,
-              updatedAt: timestamp,
-            },
+          integration: { id: integration.id, name: integration.name, kind: integration.kind, updatedAt: timestamp },
           data,
         };
-        }),
-      );
-    }),
-  subscribeToJobsAndStatuses: publicProcedure
-    .concat(createDownloadClientIntegrationMiddleware("query"))
-    .input(z.object({ limitPerIntegration: z.number().default(50) }))
-    .subscription(({ ctx, input }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"downloadClient"> }>;
-        data: DownloadClientJobsAndStatus;
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = downloadClientRequestHandler.handler(integrationWithSecrets, {
-            limit: input.limitPerIntegration,
-          });
-          const unsubscribe = innerHandler.subscribe((data) => {
-            emit.next({
-              integration,
-              data,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
       });
     }),
   pause: protectedProcedure

packages/api/src/router/widgets/firewall.ts

@@ -1,15 +1,4 @@
-import { observable } from "@trpc/server/observable";
-
-import type { Modify } from "@homarr/common/types";
-import type { Integration } from "@homarr/db/schema";
-import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type {
-  FirewallCpuSummary,
-  FirewallInterfacesSummary,
-  FirewallMemorySummary,
-  FirewallVersionSummary,
-} from "@homarr/integrations";
 import {
   firewallCpuRequestHandler,
   firewallInterfacesRequestHandler,
@@ -18,198 +7,31 @@ import {
 } from "@homarr/request-handler/firewall";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
+const firewallMiddleware = createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall"));
+
+const queryFirewall = <
+  THandler extends {
+    handler: (integration: any, input: any) => { getDataAsync: () => Promise<{ data: any; timestamp: Date }> };
+  },
+>(
+  handler: THandler,
+) =>
+  publicProcedure.concat(firewallMiddleware).query(async ({ ctx }) =>
+    settleIntegrationQueries(ctx.integrations, async (integration) => {
+      const { data, timestamp } = await handler.handler(integration, {}).getDataAsync();
+      return {
+        integration: { id: integration.id, name: integration.name, kind: integration.kind, updatedAt: timestamp },
+        summary: data as Awaited<ReturnType<ReturnType<THandler["handler"]>["getDataAsync"]>>["data"],
+      };
+    }),
+  );
+
 export const firewallRouter = createTRPCRouter({
-  getFirewallCpuStatus: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall")))
-    .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = firewallCpuRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-
-          return {
-            integration: {
-              id: integration.id,
-              name: integration.name,
-              kind: integration.kind,
-              updatedAt: timestamp,
-            },
-            summary: data,
-          };
-        }),
-      );
-      return results;
-    }),
-  subscribeFirewallCpuStatus: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall")))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"firewall"> }>;
-        summary: FirewallCpuSummary;
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = firewallCpuRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((summary) => {
-            emit.next({
-              integration,
-              summary,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
-      });
-    }),
-
-  getFirewallInterfacesStatus: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall")))
-    .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = firewallInterfacesRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-
-          return {
-            integration: {
-              id: integration.id,
-              name: integration.name,
-              kind: integration.kind,
-              updatedAt: timestamp,
-            },
-            summary: data,
-          };
-        }),
-      );
-      return results;
-    }),
-  subscribeFirewallInterfacesStatus: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall")))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"firewall"> }>;
-        summary: FirewallInterfacesSummary[];
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = firewallInterfacesRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((summary) => {
-            emit.next({
-              integration,
-              summary,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
-      });
-    }),
-
-  getFirewallVersionStatus: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall")))
-    .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = firewallVersionRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-
-          return {
-            integration: {
-              id: integration.id,
-              name: integration.name,
-              kind: integration.kind,
-              updatedAt: timestamp,
-            },
-            summary: data,
-          };
-        }),
-      );
-      return results;
-    }),
-  subscribeFirewallVersionStatus: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall")))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"firewall"> }>;
-        summary: FirewallVersionSummary;
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = firewallVersionRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((summary) => {
-            emit.next({
-              integration,
-              summary,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
-      });
-    }),
-
-  getFirewallMemoryStatus: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall")))
-    .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = firewallMemoryRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-
-          return {
-            integration: {
-              id: integration.id,
-              name: integration.name,
-              kind: integration.kind,
-              updatedAt: timestamp,
-            },
-            summary: data,
-          };
-        }),
-      );
-      return results;
-    }),
-  subscribeFirewallMemoryStatus: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("firewall")))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"firewall"> }>;
-        summary: FirewallMemorySummary;
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = firewallMemoryRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((summary) => {
-            emit.next({
-              integration,
-              summary,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
-      });
-    }),
+  getFirewallCpuStatus: queryFirewall(firewallCpuRequestHandler),
+  getFirewallInterfacesStatus: queryFirewall(firewallInterfacesRequestHandler),
+  getFirewallVersionStatus: queryFirewall(firewallVersionRequestHandler),
+  getFirewallMemoryStatus: queryFirewall(firewallMemoryRequestHandler),
 });

packages/api/src/router/widgets/health-monitoring.ts

@@ -1,10 +1,7 @@
-import { observable } from "@trpc/server/observable";
-
-import type { SystemHealthMonitoring } from "@homarr/integrations";
-import type { ProxmoxClusterInfo } from "@homarr/integrations/types";
 import { clusterInfoRequestHandler, systemInfoRequestHandler } from "@homarr/request-handler/health-monitoring";
 
 import { createManyIntegrationMiddleware, createOneIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const healthMonitoringRouter = createTRPCRouter({
@@ -20,49 +17,14 @@ export const healthMonitoringRouter = createTRPCRouter({
       createManyIntegrationMiddleware("query", "openmediavault", "dashDot", "truenas", "unraid", "glances", "mock"),
     )
     .query(async ({ ctx }) => {
-      return await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = systemInfoRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({
-            forceUpdate: false,
-          });
-
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
+        const { data, timestamp } = await systemInfoRequestHandler.handler(integration, {}).getDataAsync();
         return {
           integrationId: integration.id,
           integrationName: integration.name,
           healthInfo: data,
           updatedAt: timestamp,
         };
-        }),
-      );
-    }),
-  subscribeSystemHealthStatus: publicProcedure
-    .concat(
-      createManyIntegrationMiddleware("query", "openmediavault", "dashDot", "truenas", "unraid", "glances", "mock"),
-    )
-    .subscription(({ ctx }) => {
-      return observable<{
-        integrationId: string;
-        healthInfo: SystemHealthMonitoring;
-        timestamp: Date;
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integration of ctx.integrations) {
-          const innerHandler = systemInfoRequestHandler.handler(integration, {});
-          const unsubscribe = innerHandler.subscribe((healthInfo) => {
-            emit.next({
-              integrationId: integration.id,
-              healthInfo,
-              timestamp: new Date(),
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
       });
     }),
   getClusterHealthStatus: publicProcedure
@@ -76,24 +38,7 @@ export const healthMonitoringRouter = createTRPCRouter({
     .concat(createOneIntegrationMiddleware("query", "proxmox", "mock"))
     .query(async ({ ctx }) => {
       const innerHandler = clusterInfoRequestHandler.handler(ctx.integration, {});
-      const { data } = await innerHandler.getCachedOrUpdatedDataAsync({
-        forceUpdate: false,
-      });
+      const { data } = await innerHandler.getDataAsync();
       return data;
     }),
-  subscribeClusterHealthStatus: publicProcedure
-    .concat(createOneIntegrationMiddleware("query", "proxmox", "mock"))
-    .subscription(({ ctx }) => {
-      return observable<ProxmoxClusterInfo>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        const innerHandler = clusterInfoRequestHandler.handler(ctx.integration, {});
-        const unsubscribe = innerHandler.subscribe((healthInfo) => {
-          emit.next(healthInfo);
-        });
-        unsubscribes.push(unsubscribe);
-        return () => {
-          unsubscribe();
-        };
-      });
-    }),
 });

packages/api/src/router/widgets/immich.ts

@@ -17,7 +17,7 @@ const createImmichIntegrationMiddleware = (action: IntegrationAction) =>
 export const immichRouter = createTRPCRouter({
   getServerStats: publicProcedure.concat(createImmichIntegrationMiddleware("query")).query(async ({ ctx }) => {
     const innerHandler = immichStatsRequestHandler.handler(ctx.integration, {});
-    const data = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+    const data = await innerHandler.getDataAsync();
     return data.data;
   }),
 
@@ -30,13 +30,13 @@ export const immichRouter = createTRPCRouter({
     )
     .query(async ({ ctx, input }) => {
       const innerHandler = immichAlbumRequestHandler.handler(ctx.integration, { albumId: input.albumId });
-      const data = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+      const data = await innerHandler.getDataAsync();
       return data.data;
     }),
 
   getAlbums: publicProcedure.concat(createImmichIntegrationMiddleware("query")).query(async ({ ctx }) => {
     const innerHandler = immichAlbumsRequestHandler.handler(ctx.integration, {});
-    const data = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+    const data = await innerHandler.getDataAsync();
     return data.data;
   }),
 });

packages/api/src/router/widgets/indexer-manager.ts

@@ -1,13 +1,12 @@
 import { TRPCError } from "@trpc/server";
-import { observable } from "@trpc/server/observable";
 
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
-import type { Indexer } from "@homarr/integrations/types";
 import { indexerManagerRequestHandler } from "@homarr/request-handler/indexer-manager";
 
 import type { IntegrationAction } from "../../middlewares/integration";
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, protectedProcedure, publicProcedure } from "../../trpc";
 
 const createIndexerManagerIntegrationMiddleware = (action: IntegrationAction) =>
@@ -17,40 +16,14 @@ export const indexerManagerRouter = createTRPCRouter({
   getIndexersStatus: publicProcedure
     .concat(createIndexerManagerIntegrationMiddleware("query"))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = indexerManagerRequestHandler.handler(integration, {});
-          const { data: indexers } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data: indexers } = await innerHandler.getDataAsync();
 
         return {
           integrationId: integration.id,
           indexers,
         };
-        }),
-      );
-      return results;
-    }),
-
-  subscribeIndexersStatus: publicProcedure
-    .concat(createIndexerManagerIntegrationMiddleware("query"))
-    .subscription(({ ctx }) => {
-      return observable<{ integrationId: string; indexers: Indexer[] }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const innerHandler = indexerManagerRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((indexers) => {
-            emit.next({
-              integrationId: integrationWithSecrets.id,
-              indexers,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
       });
     }),
   testAllIndexers: protectedProcedure

packages/api/src/router/widgets/media-release.ts

@@ -1,23 +1,17 @@
-import { observable } from "@trpc/server/observable";
-
-import type { Modify } from "@homarr/common/types";
-import type { Integration } from "@homarr/db/schema";
-import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { MediaRelease } from "@homarr/integrations/types";
 import { mediaReleaseRequestHandler } from "@homarr/request-handler/media-release";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const mediaReleaseRouter = createTRPCRouter({
   getMediaReleases: publicProcedure
     .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("mediaRelease")))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      const results = await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = mediaReleaseRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
           integration: {
@@ -28,8 +22,7 @@ export const mediaReleaseRouter = createTRPCRouter({
           },
           releases: data,
         };
-        }),
-      );
+      });
       return results.flatMap((result) =>
         result.releases.map((release) => ({
           ...release,
@@ -37,31 +30,4 @@ export const mediaReleaseRouter = createTRPCRouter({
         })),
       );
     }),
-
-  subscribeToReleases: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("mediaRelease")))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"mediaRelease"> }>;
-        releases: MediaRelease[];
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = mediaReleaseRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((releases) => {
-            emit.next({
-              integration,
-              releases,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
-      });
-    }),
 });

packages/api/src/router/widgets/media-requests.ts

@@ -1,14 +1,13 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
 import { mediaRequestStatusConfiguration } from "@homarr/integrations/types";
-import type { MediaRequest } from "@homarr/integrations/types";
 import { mediaRequestListRequestHandler } from "@homarr/request-handler/media-request-list";
 import { mediaRequestStatsRequestHandler } from "@homarr/request-handler/media-request-stats";
 
 import { createManyIntegrationMiddleware, createOneIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, protectedProcedure, publicProcedure } from "../../trpc";
 
 export const mediaRequestsRouter = createTRPCRouter({
@@ -22,22 +21,10 @@ export const mediaRequestsRouter = createTRPCRouter({
     })
     .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("mediaRequest")))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = mediaRequestListRequestHandler.handler(integration, {});
-          const { data } = await innerHandler.getCachedOrUpdatedDataAsync({
-            forceUpdate: false,
+      const results = await settleIntegrationQueries(ctx.integrations, async (integration) => {
+        const { data } = await mediaRequestListRequestHandler.handler(integration, {}).getDataAsync();
+        return { integration: { id: integration.id, name: integration.name, kind: integration.kind }, data };
       });
-          return {
-            integration: {
-              id: integration.id,
-              name: integration.name,
-              kind: integration.kind,
-            },
-            data,
-          };
-        }),
-      );
       return results
         .flatMap(({ data, integration }) =>
           data.map((request) => ({
@@ -56,32 +43,6 @@ export const mediaRequestsRouter = createTRPCRouter({
           );
         });
     }),
-  subscribeToLatestRequests: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("mediaRequest")))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integrationId: string;
-        requests: MediaRequest[];
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = mediaRequestListRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((requests) => {
-            emit.next({
-              integrationId: integration.id,
-              requests,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
-      });
-    }),
   getStats: publicProcedure
     .meta({
       mcp: {
@@ -92,22 +53,10 @@ export const mediaRequestsRouter = createTRPCRouter({
     })
     .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("mediaRequest")))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = mediaRequestStatsRequestHandler.handler(integration, {});
-          const { data } = await innerHandler.getCachedOrUpdatedDataAsync({
-            forceUpdate: false,
+      const results = await settleIntegrationQueries(ctx.integrations, async (integration) => {
+        const { data } = await mediaRequestStatsRequestHandler.handler(integration, {}).getDataAsync();
+        return { integration: { id: integration.id, name: integration.name, kind: integration.kind }, data };
       });
-          return {
-            integration: {
-              id: integration.id,
-              name: integration.name,
-              kind: integration.kind,
-            },
-            data,
-          };
-        }),
-      );
       return {
         stats: results.flatMap((result) => result.data.stats),
         users: results
@@ -139,7 +88,6 @@ export const mediaRequestsRouter = createTRPCRouter({
     )
     .mutation(async ({ ctx: { integration }, input }) => {
       const integrationInstance = await createIntegrationAsync(integration);
-      const innerHandler = mediaRequestListRequestHandler.handler(integration, {});
 
       const answerActions = {
         approve: (id: number) => integrationInstance.approveRequestAsync(id),
@@ -147,6 +95,5 @@ export const mediaRequestsRouter = createTRPCRouter({
       } as const;
 
       await answerActions[input.answer](input.requestId);
-      await innerHandler.invalidateAsync();
     }),
 });

packages/api/src/router/widgets/media-server.ts

@@ -1,12 +1,11 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { StreamSession } from "@homarr/integrations";
 import { mediaServerRequestHandler } from "@homarr/request-handler/media-server";
 
 import type { IntegrationAction } from "../../middlewares/integration";
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 const createMediaServerIntegrationMiddleware = (action: IntegrationAction) =>
@@ -24,46 +23,11 @@ export const mediaServerRouter = createTRPCRouter({
     .concat(createMediaServerIntegrationMiddleware("query"))
     .input(z.object({ showOnlyPlaying: z.boolean() }))
     .query(async ({ ctx, input }) => {
-      return await Promise.all(
-        ctx.integrations.map(async (integration) => {
-          const innerHandler = mediaServerRequestHandler.handler(integration, {
-            showOnlyPlaying: input.showOnlyPlaying,
-          });
-          const { data } = await innerHandler.getCachedOrUpdatedDataAsync({
-            forceUpdate: false,
-          });
-          return {
-            integrationId: integration.id,
-            integrationKind: integration.kind,
-            sessions: data,
-          };
-        }),
-      );
-    }),
-  subscribeToCurrentStreams: publicProcedure
-    .concat(createMediaServerIntegrationMiddleware("query"))
-    .input(z.object({ showOnlyPlaying: z.boolean() }))
-    .subscription(({ ctx, input }) => {
-      return observable<{ integrationId: string; data: StreamSession[] }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integration of ctx.integrations) {
-          const innerHandler = mediaServerRequestHandler.handler(integration, {
-            showOnlyPlaying: input.showOnlyPlaying,
-          });
-
-          const unsubscribe = innerHandler.subscribe((sessions) => {
-            emit.next({
-              integrationId: integration.id,
-              data: sessions,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
+        const { data } = await mediaServerRequestHandler
+          .handler(integration, { showOnlyPlaying: input.showOnlyPlaying })
+          .getDataAsync();
+        return { integrationId: integration.id, integrationKind: integration.kind, sessions: data };
       });
     }),
 });

packages/api/src/router/widgets/media-transcoding.ts

@@ -1,7 +1,4 @@
-import { observable } from "@trpc/server/observable";
-
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { MediaTranscoding } from "@homarr/request-handler/media-transcoding";
 import { mediaTranscodingRequestHandler } from "@homarr/request-handler/media-transcoding";
 import { paginatedSchema } from "@homarr/validation/common";
 
@@ -21,26 +18,11 @@ export const mediaTranscodingRouter = createTRPCRouter({
         pageOffset: (input.page - 1) * input.pageSize,
         pageSize: input.pageSize,
       });
-      const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+      const { data } = await innerHandler.getDataAsync();
 
       return {
         integrationId: ctx.integration.id,
         data,
       };
     }),
-  subscribeData: publicProcedure
-    .concat(createIndexerManagerIntegrationMiddleware("query"))
-    .input(paginatedSchema.pick({ page: true, pageSize: true }))
-    .subscription(({ ctx, input }) => {
-      return observable<{ integrationId: string; data: MediaTranscoding }>((emit) => {
-        const innerHandler = mediaTranscodingRequestHandler.handler(ctx.integration, {
-          pageOffset: (input.page - 1) * input.pageSize,
-          pageSize: input.pageSize,
-        });
-        const unsubscribe = innerHandler.subscribe((data) => {
-          emit.next({ integrationId: input.integrationId, data });
-        });
-        return unsubscribe;
-      });
-    }),
 });

packages/api/src/router/widgets/minecraft.ts

@@ -1,7 +1,5 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
-import type { MinecraftServerStatus } from "@homarr/request-handler/minecraft-server-status";
 import { minecraftServerStatusRequestHandler } from "@homarr/request-handler/minecraft-server-status";
 
 import { createTRPCRouter, publicProcedure } from "../../trpc";
@@ -16,21 +14,6 @@ export const minecraftRouter = createTRPCRouter({
       isBedrockServer: input.isBedrockServer,
       domain: input.domain,
     });
-    return await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: true });
-  }),
-  subscribeServerStatus: publicProcedure.input(serverStatusInputSchema).subscription(({ input }) => {
-    return observable<MinecraftServerStatus>((emit) => {
-      const innerHandler = minecraftServerStatusRequestHandler.handler({
-        isBedrockServer: input.isBedrockServer,
-        domain: input.domain,
-      });
-      const unsubscribe = innerHandler.subscribe((data) => {
-        emit.next(data);
-      });
-
-      return () => {
-        unsubscribe();
-      };
-    });
+    return await innerHandler.getDataAsync();
   }),
 });

packages/api/src/router/widgets/network-controller.ts

@@ -1,23 +1,17 @@
-import { observable } from "@trpc/server/observable";
-
-import type { Modify } from "@homarr/common/types";
-import type { Integration } from "@homarr/db/schema";
-import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { NetworkControllerSummary } from "@homarr/integrations/types";
 import { networkControllerRequestHandler } from "@homarr/request-handler/network-controller";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const networkControllerRouter = createTRPCRouter({
   summary: publicProcedure
     .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("networkController")))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = networkControllerRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
           integration: {
@@ -28,35 +22,6 @@ export const networkControllerRouter = createTRPCRouter({
           summary: data,
           updatedAt: timestamp,
         };
-        }),
-      );
-      return results;
-    }),
-
-  subscribeToSummary: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("networkController")))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"networkController"> }>;
-        summary: NetworkControllerSummary;
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = networkControllerRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((summary) => {
-            emit.next({
-              integration,
-              summary,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
       });
     }),
 });

packages/api/src/router/widgets/notifications.ts

@@ -1,14 +1,9 @@
-import { observable } from "@trpc/server/observable";
-
-import type { Modify } from "@homarr/common/types";
-import type { Integration } from "@homarr/db/schema";
-import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { Notification } from "@homarr/integrations";
 import { notificationsRequestHandler } from "@homarr/request-handler/notifications";
 
 import type { IntegrationAction } from "../../middlewares/integration";
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 const createNotificationsIntegrationMiddleware = (action: IntegrationAction) =>
@@ -18,10 +13,9 @@ export const notificationsRouter = createTRPCRouter({
   getNotifications: publicProcedure
     .unstable_concat(createNotificationsIntegrationMiddleware("query"))
     .query(async ({ ctx }) => {
-      return await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = notificationsRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
           integration: {
@@ -32,33 +26,6 @@ export const notificationsRouter = createTRPCRouter({
           },
           data,
         };
-        }),
-      );
-    }),
-  subscribeNotifications: publicProcedure
-    .unstable_concat(createNotificationsIntegrationMiddleware("query"))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integration: Modify<Integration, { kind: IntegrationKindByCategory<"notifications"> }>;
-        data: Notification[];
-      }>((emit) => {
-        const unsubscribes: (() => void)[] = [];
-        for (const integrationWithSecrets of ctx.integrations) {
-          const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const innerHandler = notificationsRequestHandler.handler(integrationWithSecrets, {});
-          const unsubscribe = innerHandler.subscribe((data) => {
-            emit.next({
-              integration,
-              data,
-            });
-          });
-          unsubscribes.push(unsubscribe);
-        }
-        return () => {
-          unsubscribes.forEach((unsubscribe) => {
-            unsubscribe();
-          });
-        };
       });
     }),
 });

packages/api/src/router/widgets/paperless-ngx.ts

@@ -6,7 +6,7 @@ import { createTRPCRouter, publicProcedure } from "../../trpc";
 export const paperlessNgxRouter = createTRPCRouter({
   getStats: publicProcedure.concat(createOneIntegrationMiddleware("query", "paperlessNgx")).query(async ({ ctx }) => {
     const innerHandler = paperlessNgxStatsRequestHandler.handler(ctx.integration, {});
-    const data = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+    const data = await innerHandler.getDataAsync();
     return data.data;
   }),
 });

packages/api/src/router/widgets/releases.ts

@@ -89,9 +89,7 @@ export const releasesRouter = createTRPCRouter({
                 providerUrl: repository.providerUrl,
                 token: useToken ? tokensByProvider.get(repository.provider) : undefined,
               })
-              .getCachedOrUpdatedDataAsync({
-                forceUpdate: false,
-              });
+              .getDataAsync();
 
             return {
               id: repositoryId,

packages/api/src/router/widgets/rssFeed.ts

@@ -1,4 +1,3 @@
-import { observable } from "@trpc/server/observable";
 import SuperJSON from "superjson";
 import { z } from "zod/v4";
 
@@ -6,12 +5,14 @@ import type { Session } from "@homarr/auth";
 import type { Database } from "@homarr/db";
 import { eq } from "@homarr/db";
 import { items, users } from "@homarr/db/schema";
-import type { ExtendedFeedEntry } from "@homarr/request-handler/rss-feeds";
+import { createLogger } from "@homarr/core/infrastructure/logs";
 import { rssFeedsRequestHandler } from "@homarr/request-handler/rss-feeds";
 
 import type { WidgetComponentProps } from "../../../../widgets/src";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
+const logger = createLogger({ module: "rssFeed" });
+
 const feedsInput = z.object({
   urls: z.array(z.string()).max(100),
   maximumAmountPosts: z.number(),
@@ -23,41 +24,28 @@ export const rssFeedRouter = createTRPCRouter({
       ? input.urls
       : await restrictUrlsAsync(ctx.db, input.urls);
 
-    const rssFeeds = await Promise.all(
+    const settled = await Promise.allSettled(
       urls.map(async (url) => {
         const innerHandler = rssFeedsRequestHandler.handler({
           url,
           count: input.maximumAmountPosts,
         });
-        return await innerHandler.getCachedOrUpdatedDataAsync({
-          forceUpdate: false,
-        });
+        return await innerHandler.getDataAsync();
       }),
     );
 
-    return rssFeeds
-      .flatMap((rssFeed) => rssFeed.data.entries)
-      .slice(0, input.maximumAmountPosts)
-      .sort((entryA, entryB) => {
+    return settled
+      .flatMap((result, index) => {
+        if (result.status === "fulfilled") return result.value.data.entries;
+        logger.warn("RSS feed fetch failed", { url: urls[index], error: result.reason });
+        return [];
+      })
+      .toSorted((entryA, entryB) => {
         return entryA.published && entryB.published
           ? new Date(entryB.published).getTime() - new Date(entryA.published).getTime()
           : 0;
-      });
-  }),
-  subscribeFeeds: publicProcedure.input(feedsInput).subscription(({ input }) => {
-    // It is not necessary to check access to all feeds here, as the client will only subscribe to feeds which already exist
-    return observable<{ url: string; entries: ExtendedFeedEntry[] }>((emit) => {
-      const unsubscribes = input.urls.map((url) => {
-        const innerHandler = rssFeedsRequestHandler.handler({ url, count: input.maximumAmountPosts });
-        return innerHandler.subscribe((data) => {
-          emit.next({ url, entries: data.entries });
-        });
-      });
-
-      return () => {
-        unsubscribes.forEach((unsubscribe) => unsubscribe());
-      };
-    });
+      })
+      .slice(0, input.maximumAmountPosts);
   }),
 });
 

packages/api/src/router/widgets/smart-home.ts

@@ -1,4 +1,3 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
@@ -25,31 +24,9 @@ export const smartHomeRouter = createTRPCRouter({
     .concat(createSmartHomeIntegrationMiddleware("query"))
     .query(async ({ ctx: { integration }, input }) => {
       const innerHandler = smartHomeEntityStateRequestHandler.handler(integration, { entityId: input.entityId });
-      const { data } = await innerHandler.getCachedOrUpdatedDataAsync({
-        forceUpdate: false,
-      });
+      const { data } = await innerHandler.getDataAsync();
       return data;
     }),
-  subscribeEntityState: publicProcedure
-    .concat(createSmartHomeIntegrationMiddleware("query"))
-    .input(z.object({ entityId: z.string() }))
-    .subscription(({ input, ctx }) => {
-      return observable<{
-        entityId: string;
-        state: string;
-      }>((emit) => {
-        const innerHandler = smartHomeEntityStateRequestHandler.handler(ctx.integration, {
-          entityId: input.entityId,
-        });
-        const unsubscribe = innerHandler.subscribe((state) => {
-          emit.next({ state, entityId: input.entityId });
-        });
-
-        return () => {
-          unsubscribe();
-        };
-      });
-    }),
   switchEntity: protectedProcedure
     .meta({
       mcp: {
@@ -64,9 +41,6 @@ export const smartHomeRouter = createTRPCRouter({
       const client = await createIntegrationAsync(integration);
       const success = await client.triggerToggleAsync(input.entityId);
 
-      const innerHandler = smartHomeEntityStateRequestHandler.handler(integration, { entityId: input.entityId });
-      await innerHandler.invalidateAsync();
-
       return success;
     }),
   executeAutomation: protectedProcedure

packages/api/src/router/widgets/speedtest-tracker.ts

@@ -1,19 +1,16 @@
-import { observable } from "@trpc/server/observable";
-
-import type { SpeedtestTrackerDashboardData } from "@homarr/integrations/types";
 import { speedtestTrackerRequestHandler } from "@homarr/request-handler/speedtest-tracker";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const speedtestTrackerRouter = createTRPCRouter({
   getDashboard: publicProcedure
     .concat(createManyIntegrationMiddleware("query", "speedtestTracker"))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = speedtestTrackerRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
           integrationId: integration.id,
@@ -22,34 +19,6 @@ export const speedtestTrackerRouter = createTRPCRouter({
           dashboard: data,
           updatedAt: timestamp,
         };
-        }),
-      );
-
-      return results;
-    }),
-
-  subscribeToDashboard: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", "speedtestTracker"))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integrationId: string;
-        dashboard: SpeedtestTrackerDashboardData;
-        timestamp: Date;
-      }>((emit) => {
-        const unsubscribes = ctx.integrations.map((integration) => {
-          const innerHandler = speedtestTrackerRequestHandler.handler(integration, {});
-          return innerHandler.subscribe((dashboard) => {
-            emit.next({
-              integrationId: integration.id,
-              dashboard,
-              timestamp: new Date(),
-            });
-          });
-        });
-
-        return () => {
-          unsubscribes.forEach((unsubscribe) => unsubscribe());
-        };
       });
     }),
 });

packages/api/src/router/widgets/stocks.ts

@@ -18,6 +18,6 @@ export const stockPriceRouter = createTRPCRouter({
       timeRange: input.timeRange,
       timeInterval: input.timeInterval,
     });
-    return await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+    return await innerHandler.getDataAsync();
   }),
 });

packages/api/src/router/widgets/timetable.ts

@@ -19,14 +19,7 @@ export const timetableRouter = createTRPCRouter({
       }),
     )
     .query(async ({ input }) => {
-      const innerHandler = timetableGetTimetableRequestHandler.handler({
-        baseUrl: input.baseUrl,
-        stationId: input.stationId,
-        limit: input.limit,
-      });
-
-      const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-
+      const { data } = await timetableGetTimetableRequestHandler.handler(input).getDataAsync();
       return data;
     }),
   searchStations: publicProcedure
@@ -37,13 +30,7 @@ export const timetableRouter = createTRPCRouter({
       }),
     )
     .query(async ({ input }) => {
-      const innerHandler = timetableSearchStationsRequestHandler.handler({
-        baseUrl: input.baseUrl,
-        query: input.query,
-      });
-
-      const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-
+      const { data } = await timetableSearchStationsRequestHandler.handler(input).getDataAsync();
       return data;
     }),
 });

packages/api/src/router/widgets/tracearr.ts

@@ -1,17 +1,14 @@
-import { observable } from "@trpc/server/observable";
-
-import type { TracearrDashboardData } from "@homarr/integrations/types";
 import { tracearrRequestHandler } from "@homarr/request-handler/tracearr";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const tracearrRouter = createTRPCRouter({
   getDashboard: publicProcedure.concat(createManyIntegrationMiddleware("query", "tracearr")).query(async ({ ctx }) => {
-    const results = await Promise.all(
-      ctx.integrations.map(async (integration) => {
+    return await settleIntegrationQueries(ctx.integrations, async (integration) => {
       const innerHandler = tracearrRequestHandler.handler(integration, {});
-        const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+      const { data, timestamp } = await innerHandler.getDataAsync();
 
       return {
         integrationId: integration.id,
@@ -20,29 +17,6 @@ export const tracearrRouter = createTRPCRouter({
         dashboard: data,
         updatedAt: timestamp,
       };
-      }),
-    );
-
-    return results;
-  }),
-  subscribeToDashboard: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", "tracearr"))
-    .subscription(({ ctx }) => {
-      return observable<{ integrationId: string; dashboard: TracearrDashboardData; timestamp: Date }>((emit) => {
-        const unsubscribes = ctx.integrations.map((integration) => {
-          const innerHandler = tracearrRequestHandler.handler(integration, {});
-          return innerHandler.subscribe((dashboard) => {
-            emit.next({
-              integrationId: integration.id,
-              dashboard,
-              timestamp: new Date(),
-            });
-          });
-        });
-
-        return () => {
-          unsubscribes.forEach((unsubscribe) => unsubscribe());
-        };
     });
   }),
 });

packages/api/src/router/widgets/umami.ts

@@ -1,4 +1,3 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
 import { createLogger } from "@homarr/core/infrastructure/logs";
@@ -14,6 +13,7 @@ import {
 } from "@homarr/request-handler/umami";
 
 import { createManyIntegrationMiddleware, createOneIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 const logger = createLogger({ module: "umami-router" });
@@ -39,14 +39,13 @@ export const umamiRouter = createTRPCRouter({
     )
     .concat(createManyIntegrationMiddleware("query", "umami"))
     .query(async ({ ctx, input }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = umamiRequestHandler.handler(integration, {
           websiteId: input.websiteId,
           timeFrame: input.timeFrame,
           eventName: input.eventName,
         });
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
           integrationId: integration.id,
@@ -55,10 +54,7 @@ export const umamiRouter = createTRPCRouter({
           visitorStats: data,
           updatedAt: timestamp,
         };
-        }),
-      );
-
-      return results;
+      });
     }),
 
   getEventNames: publicProcedure
@@ -67,7 +63,7 @@ export const umamiRouter = createTRPCRouter({
     .query(async ({ ctx, input }) => {
       try {
         const innerHandler = umamiEventNamesRequestHandler.handler(ctx.integration, { websiteId: input.websiteId });
-        const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data } = await innerHandler.getDataAsync();
         return data;
       } catch (error) {
         logger.warn(
@@ -93,7 +89,7 @@ export const umamiRouter = createTRPCRouter({
           timeFrame: input.timeFrame,
           limit: input.limit,
         });
-        const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data } = await innerHandler.getDataAsync();
         return data;
       } catch (error) {
         logger.warn(
@@ -123,7 +119,7 @@ export const umamiRouter = createTRPCRouter({
           timeFrame: input.timeFrame,
           limit: input.limit,
         });
-        const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data } = await innerHandler.getDataAsync();
         return data;
       } catch (error) {
         logger.warn(
@@ -148,13 +144,13 @@ export const umamiRouter = createTRPCRouter({
     .concat(createOneIntegrationMiddleware("query", "umami"))
     .query(async ({ ctx, input }) => {
       try {
-        const sortedNames = [...input.eventNames].sort();
+        const sortedNames = [...input.eventNames].toSorted();
         const innerHandler = umamiMultiEventRequestHandler.handler(ctx.integration, {
           websiteId: input.websiteId,
           timeFrame: input.timeFrame,
           eventNames: sortedNames,
         });
-        const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data } = await innerHandler.getDataAsync();
         return data;
       } catch (error) {
         logger.warn(
@@ -176,7 +172,7 @@ export const umamiRouter = createTRPCRouter({
         const innerHandler = umamiActiveVisitorsRequestHandler.handler(ctx.integration, {
           websiteId: input.websiteId,
         });
-        const { data } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data } = await innerHandler.getDataAsync();
         return data;
       } catch (error) {
         logger.warn(
@@ -185,21 +181,4 @@ export const umamiRouter = createTRPCRouter({
         return 0;
       }
     }),
-
-  subscribeActiveVisitors: publicProcedure
-    .input(z.object({ websiteId: z.string() }))
-    .concat(createOneIntegrationMiddleware("query", "umami"))
-    .subscription(({ ctx, input }) => {
-      return observable<number>((emit) => {
-        const innerHandler = umamiActiveVisitorsRequestHandler.handler(ctx.integration, {
-          websiteId: input.websiteId,
-        });
-        const unsubscribe = innerHandler.subscribe((count) => {
-          emit.next(count);
-        });
-        return () => {
-          unsubscribe();
-        };
-      });
-    }),
 });

packages/api/src/router/widgets/ups.ts

@@ -1,20 +1,17 @@
-import { observable } from "@trpc/server/observable";
-
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { UpsSummary } from "@homarr/integrations/types";
 import { upsSummariesRequestHandler } from "@homarr/request-handler/ups";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const upsRouter = createTRPCRouter({
   getSummaries: publicProcedure
     .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("ups")))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = upsSummariesRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
           integrationId: integration.id,
@@ -23,29 +20,6 @@ export const upsRouter = createTRPCRouter({
           summaries: data,
           updatedAt: timestamp,
         };
-        }),
-      );
-
-      return results;
-    }),
-  subscribeSummaries: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("ups")))
-    .subscription(({ ctx }) => {
-      return observable<{ integrationId: string; summaries: UpsSummary[]; timestamp: Date }>((emit) => {
-        const unsubscribes = ctx.integrations.map((integration) => {
-          const innerHandler = upsSummariesRequestHandler.handler(integration, {});
-          return innerHandler.subscribe((summaries) => {
-            emit.next({
-              integrationId: integration.id,
-              summaries,
-              timestamp: new Date(),
-            });
-          });
-        });
-
-        return () => {
-          unsubscribes.forEach((unsubscribe) => unsubscribe());
-        };
       });
     }),
 });

packages/api/src/router/widgets/uptime-kuma.ts

@@ -1,19 +1,16 @@
-import { observable } from "@trpc/server/observable";
-
-import type { UptimeKumaDashboardData } from "@homarr/integrations/types";
 import { uptimeKumaRequestHandler } from "@homarr/request-handler/uptime-kuma";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const uptimeKumaRouter = createTRPCRouter({
   getDashboard: publicProcedure
     .concat(createManyIntegrationMiddleware("query", "uptimeKuma"))
     .query(async ({ ctx }) => {
-      const results = await Promise.all(
-        ctx.integrations.map(async (integration) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = uptimeKumaRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
           integrationId: integration.id,
@@ -22,34 +19,6 @@ export const uptimeKumaRouter = createTRPCRouter({
           dashboard: data,
           updatedAt: timestamp,
         };
-        }),
-      );
-
-      return results;
-    }),
-
-  subscribeToDashboard: publicProcedure
-    .concat(createManyIntegrationMiddleware("query", "uptimeKuma"))
-    .subscription(({ ctx }) => {
-      return observable<{
-        integrationId: string;
-        dashboard: UptimeKumaDashboardData;
-        timestamp: Date;
-      }>((emit) => {
-        const unsubscribes = ctx.integrations.map((integration) => {
-          const innerHandler = uptimeKumaRequestHandler.handler(integration, {});
-          return innerHandler.subscribe((dashboard) => {
-            emit.next({
-              integrationId: integration.id,
-              dashboard,
-              timestamp: new Date(),
-            });
-          });
-        });
-
-        return () => {
-          unsubscribes.forEach((unsubscribe) => unsubscribe());
-        };
       });
     }),
 });

packages/api/src/router/widgets/vpn.ts

@@ -1,25 +1,16 @@
-import { observable } from "@trpc/server/observable";
-
-import type { Modify } from "@homarr/common/types";
-import type { Integration } from "@homarr/db/schema";
-import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import type { VpnSummary } from "@homarr/integrations/types";
 import { vpnSummaryHandler } from "@homarr/request-handler/vpn";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
-const createVpnIntegrationMiddleware = () =>
-  createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("vpn"));
-
 export const vpnRouter = createTRPCRouter({
-  getSummaries: publicProcedure.unstable_concat(createVpnIntegrationMiddleware()).query(async ({ ctx }) => {
-    return await Promise.all(
-      ctx.integrations.map(async (integration) => {
-        const innerHandler = vpnSummaryHandler.handler(integration, {});
-        const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
-
+  getSummaries: publicProcedure
+    .unstable_concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("vpn")))
+    .query(async ({ ctx }) => {
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
+        const { data, timestamp } = await vpnSummaryHandler.handler(integration, {}).getDataAsync();
         return {
           integration: {
             id: integration.id,
@@ -29,31 +20,6 @@ export const vpnRouter = createTRPCRouter({
           },
           summary: data,
         };
-      }),
-    );
-  }),
-  subscribeSummaries: publicProcedure.unstable_concat(createVpnIntegrationMiddleware()).subscription(({ ctx }) => {
-    return observable<{
-      integration: Modify<Integration, { kind: IntegrationKindByCategory<"vpn"> }>;
-      summary: VpnSummary | null;
-    }>((emit) => {
-      const unsubscribes: (() => void)[] = [];
-      for (const integrationWithSecrets of ctx.integrations) {
-        const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-        const innerHandler = vpnSummaryHandler.handler(integrationWithSecrets, {});
-        const unsubscribe = innerHandler.subscribe((summary) => {
-          emit.next({
-            integration,
-            summary,
-          });
-        });
-        unsubscribes.push(unsubscribe);
-      }
-      return () => {
-        unsubscribes.forEach((unsubscribe) => {
-          unsubscribe();
-        });
-      };
       });
     }),
 });

packages/api/src/router/widgets/weather.ts

@@ -1,7 +1,5 @@
-import { observable } from "@trpc/server/observable";
 import { z } from "zod/v4";
 
-import type { Weather } from "@homarr/request-handler/weather";
 import { weatherRequestHandler } from "@homarr/request-handler/weather";
 
 import { createTRPCRouter, publicProcedure } from "../../trpc";
@@ -14,16 +12,6 @@ const atLocationInput = z.object({
 export const weatherRouter = createTRPCRouter({
   atLocation: publicProcedure.input(atLocationInput).query(async ({ input }) => {
     const handler = weatherRequestHandler.handler(input);
-    return await handler.getCachedOrUpdatedDataAsync({ forceUpdate: false }).then((result) => result.data);
-  }),
-  subscribeAtLocation: publicProcedure.input(atLocationInput).subscription(({ input }) => {
-    return observable<Weather>((emit) => {
-      const handler = weatherRequestHandler.handler(input);
-      const unsubscribe = handler.subscribe((data) => {
-        emit.next(data);
-      });
-
-      return unsubscribe;
-    });
+    return await handler.getDataAsync().then((result) => result.data);
   }),
 });

packages/api/src/services/duckduckgo-bangs.ts

@@ -39,7 +39,7 @@ export const searchDuckDuckGoBangsAsync = async (input: {
   const queryTokenPrefix = normalizeBangToken(input.query);
   if (!queryTokenPrefix) return [];
 
-  const { data: allBangs } = await duckDuckGoBangsRequestHandler.handler({}).getCachedOrUpdatedDataAsync({});
+  const { data: allBangs } = await duckDuckGoBangsRequestHandler.handler({}).getDataAsync();
   const startIndex = lowerBound(allBangs, queryTokenPrefix);
   const matches: DuckDuckGoBang[] = [];
 

packages/api/src/settle-integrations.ts

@@ -0,0 +1,29 @@
+import { createLogger } from "@homarr/core/infrastructure/logs";
+import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
+
+const logger = createLogger({ module: "settleIntegrations" });
+
+interface IntegrationLike {
+  id: string;
+  name: string;
+  kind: string;
+}
+
+export async function settleIntegrationQueries<TIntegration extends IntegrationLike, TResult>(
+  integrations: TIntegration[],
+  fn: (integration: TIntegration) => Promise<TResult>,
+): Promise<TResult[]> {
+  const settled = await Promise.allSettled(integrations.map(async (integration) => fn(integration)));
+  return settled.flatMap((result, index) => {
+    if (result.status === "fulfilled") return [result.value];
+    const integration = integrations[index];
+    logger.warn(
+      new ErrorWithMetadata(
+        "Integration query failed",
+        { integrationId: integration?.id, integrationKind: integration?.kind },
+        { cause: result.reason },
+      ),
+    );
+    return [];
+  });
+}

packages/api/src/test/query-cache.spec.ts

@@ -10,59 +10,31 @@ import {
   isPersistableWidgetQueryKey,
   queryCacheDefaultStaleTimeMs,
   queryCacheMaxValueBytes,
-  queryCacheRetentionMs,
 } from "@homarr/api/query-cache";
 
 import { queryCacheRouter } from "../router/query-cache";
 
 const redisMock = vi.hoisted(() => {
-  const values = new Map<string, { value: string; expiresAt: number }>();
-  const calls: {
-    userId: string;
-    boardId: string;
-    key: string;
-    ttlMs: number;
-    maxValueBytes: number;
-  }[] = [];
+  const values = new Map<string, string>();
 
   return {
     values,
-    calls,
-    createQueryCacheChannel: vi.fn(
-      (options: { userId: string; boardId: string; key: string; ttlMs: number; maxValueBytes: number }) => {
-        calls.push(options);
-        const storageKey = `${options.userId}:${options.boardId}:${options.key}`;
-
-        return {
-          getAsync: async () => {
-            const item = values.get(storageKey);
-            if (!item) return null;
-            if (Date.now() > item.expiresAt) {
-              values.delete(storageKey);
-              return null;
-            }
-
-            return item.value;
-          },
-          setAsync: async (value: string) => {
-            if (Buffer.byteLength(value, "utf8") > options.maxValueBytes) {
-              return false;
-            }
-
-            values.set(storageKey, { value, expiresAt: Date.now() + options.ttlMs });
+    setQueryCacheAsync: vi.fn(
+      async (_userId: string, _boardId: string, value: string, _ttlMs: number, maxValueBytes: number) => {
+        if (Buffer.byteLength(value, "utf8") > maxValueBytes) return false;
+        values.set(`${_userId}:${_boardId}`, value);
         return true;
       },
-          removeAsync: async () => {
-            values.delete(storageKey);
-          },
-        };
-      },
     ),
+    removeQueryCacheAsync: vi.fn(async (_userId: string, _boardId: string) => {
+      values.delete(`${_userId}:${_boardId}`);
+    }),
   };
 });
 
 vi.mock("@homarr/redis", () => ({
-  createQueryCacheChannel: redisMock.createQueryCacheChannel,
+  setQueryCacheAsync: redisMock.setQueryCacheAsync,
+  removeQueryCacheAsync: redisMock.removeQueryCacheAsync,
 }));
 
 vi.mock("@homarr/auth", () => ({ auth: () => ({}) as Session }));
@@ -70,8 +42,8 @@ vi.mock("@homarr/auth", () => ({ auth: () => ({}) as Session }));
 afterEach(() => {
   vi.useRealTimers();
   redisMock.values.clear();
-  redisMock.calls.length = 0;
-  redisMock.createQueryCacheChannel.mockClear();
+  redisMock.setQueryCacheAsync.mockClear();
+  redisMock.removeQueryCacheAsync.mockClear();
 });
 
 const createSession = (userId = createId()): Session => ({
@@ -104,7 +76,7 @@ describe("isPersistableWidgetQueryKey", () => {
 });
 
 describe("queryCacheRouter", () => {
-  test("stores, reads, and removes data for a board viewer", async () => {
+  test("stores and removes data for a board viewer", async () => {
     const db = createDb();
     const session = createSession();
     await insertUserAsync(db, session.user.id);
@@ -112,14 +84,19 @@ describe("queryCacheRouter", () => {
 
     const caller = queryCacheRouter.createCaller({ db, deviceType: undefined, session });
 
-    await expect(caller.setItem({ boardId: "board-1", key: "query-key", value: "cached-value" })).resolves.toEqual({
+    await expect(caller.setItem({ boardId: "board-1", value: "cached-value" })).resolves.toEqual({
       stored: true,
     });
-    await expect(caller.getItem({ boardId: "board-1", key: "query-key" })).resolves.toBe("cached-value");
+    expect(redisMock.setQueryCacheAsync).toHaveBeenCalledWith(
+      session.user.id,
+      "board-1",
+      "cached-value",
+      expect.any(Number),
+      queryCacheMaxValueBytes,
+    );
 
-    await caller.removeItem({ boardId: "board-1", key: "query-key" });
-
-    await expect(caller.getItem({ boardId: "board-1", key: "query-key" })).resolves.toBeNull();
+    await caller.removeItem({ boardId: "board-1" });
+    expect(redisMock.removeQueryCacheAsync).toHaveBeenCalledWith(session.user.id, "board-1");
   });
 
   test("does not touch Redis when board access is denied", async () => {
@@ -127,32 +104,32 @@ describe("queryCacheRouter", () => {
     await insertUserAsync(db, "owner");
     await db.insert(boards).values({ id: "board-1", name: "board", creatorId: "owner", isPublic: false });
 
-    redisMock.createQueryCacheChannel.mockClear();
+    redisMock.setQueryCacheAsync.mockClear();
     const caller = queryCacheRouter.createCaller({ db, deviceType: undefined, session: createSession("other-user") });
 
-    await expect(caller.getItem({ boardId: "board-1", key: "query-key" })).rejects.toThrow("Board not found");
-    expect(redisMock.createQueryCacheChannel).not.toHaveBeenCalled();
+    await expect(caller.setItem({ boardId: "board-1", value: "cached-value" })).rejects.toThrow("Board not found");
+    expect(redisMock.setQueryCacheAsync).not.toHaveBeenCalled();
   });
 
-  test("scopes anonymous public-board cache entries by anonymous user and board", async () => {
+  test("scopes anonymous public-board cache entries by anonymous user", async () => {
     const db = createDb();
     await insertUserAsync(db, "owner");
     await db.insert(boards).values({ id: "board-1", name: "board", creatorId: "owner", isPublic: true });
 
     const caller = queryCacheRouter.createCaller({ db, deviceType: undefined, session: null });
 
-    await caller.setItem({ boardId: "board-1", key: "query-key", value: "cached-value" });
+    await caller.setItem({ boardId: "board-1", value: "cached-value" });
 
-    expect(redisMock.calls.at(-1)).toMatchObject({
-      userId: "anonymous",
-      boardId: "board-1",
-      key: "query-key",
-      ttlMs: queryCacheRetentionMs,
-      maxValueBytes: queryCacheMaxValueBytes,
-    });
+    expect(redisMock.setQueryCacheAsync).toHaveBeenCalledWith(
+      "anonymous",
+      "board-1",
+      "cached-value",
+      expect.any(Number),
+      queryCacheMaxValueBytes,
+    );
   });
 
-  test("scopes signed-in cache entries by user and rejects oversized values", async () => {
+  test("rejects oversized values", async () => {
     const db = createDb();
     const session = createSession("user-1");
     await insertUserAsync(db, session.user.id);
@@ -161,34 +138,9 @@ describe("queryCacheRouter", () => {
     const caller = queryCacheRouter.createCaller({ db, deviceType: undefined, session });
     const value = "x".repeat(queryCacheMaxValueBytes + 1);
 
-    await expect(caller.setItem({ boardId: "board-1", key: "query-key", value })).resolves.toEqual({
+    await expect(caller.setItem({ boardId: "board-1", value })).resolves.toEqual({
       stored: false,
     });
-    expect(redisMock.calls.at(-1)).toMatchObject({
-      userId: "user-1",
-      boardId: "board-1",
-      ttlMs: queryCacheRetentionMs,
-      maxValueBytes: queryCacheMaxValueBytes,
-    });
-  });
-
-  test("expires values through the Redis TTL path", async () => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date("2026-01-01T00:00:00.000Z"));
-
-    const db = createDb();
-    const session = createSession("user-1");
-    await insertUserAsync(db, session.user.id);
-    await db.insert(boards).values({ id: "board-1", name: "board", creatorId: session.user.id, isPublic: false });
-
-    const caller = queryCacheRouter.createCaller({ db, deviceType: undefined, session });
-
-    await caller.setItem({ boardId: "board-1", key: "query-key", value: "cached-value" });
-    await expect(caller.getItem({ boardId: "board-1", key: "query-key" })).resolves.toBe("cached-value");
-
-    await vi.advanceTimersByTimeAsync(queryCacheRetentionMs + 1);
-
-    await expect(caller.getItem({ boardId: "board-1", key: "query-key" })).resolves.toBeNull();
   });
 });
 

packages/boards/src/context.tsx

@@ -20,16 +20,7 @@ export const BoardProvider = ({
 }: PropsWithChildren<{
   initialBoard: RouterOutputs["board"]["getBoardByName"];
 }>) => {
-  const { data } = clientApi.board.getBoardByName.useQuery(
-    { name: initialBoard.name },
-    {
-      initialData: initialBoard,
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-    },
-  );
-
-  setActiveQueryCacheBoardId(data.id);
+  const { data } = clientApi.board.getBoardByName.useQuery({ name: initialBoard.name }, { initialData: initialBoard });
 
   // Update the board name so it can be used within updateBoard method
   updateBoardName(initialBoard.name);

packages/common/src/date.ts

@@ -17,6 +17,12 @@ export function formatDuration(milliseconds: number) {
   return `${minutes}:${String(seconds).padStart(2, "0")}`;
 }
 
+export const toValidDate = (value: unknown): Date | null => {
+  if (value == null || typeof value === "boolean") return null;
+  const date = value instanceof Date ? value : new Date(value as string | number);
+  return Number.isFinite(date.getTime()) ? date : null;
+};
+
 export const isDateWithin = (date: Date, relativeDate: string): boolean => {
   if (relativeDate.length < 2) {
     throw new Error("Relative date must be at least 2 characters long");

packages/cron-jobs/src/index.ts

@@ -1,32 +1,6 @@
 import { analyticsJob } from "./jobs/analytics";
-import { dockerContainersJob } from "./jobs/docker";
 import { iconsUpdaterJob } from "./jobs/icons-updater";
-import { dnsHoleJob } from "./jobs/integrations/dns-hole";
-import { downloadsJob } from "./jobs/integrations/downloads";
-import {
-  firewallCpuJob,
-  firewallInterfacesJob,
-  firewallMemoryJob,
-  firewallVersionJob,
-} from "./jobs/integrations/firewall";
-import { healthMonitoringJob } from "./jobs/integrations/health-monitoring";
-import { smartHomeEntityStateJob } from "./jobs/integrations/home-assistant";
-import { indexerManagerJob } from "./jobs/integrations/indexer-manager";
-import { mediaOrganizerJob } from "./jobs/integrations/media-organizer";
-import { mediaRequestListJob, mediaRequestStatsJob } from "./jobs/integrations/media-requests";
-import { mediaServerJob } from "./jobs/integrations/media-server";
-import { mediaTranscodingJob } from "./jobs/integrations/media-transcoding";
-import { networkControllerJob } from "./jobs/integrations/network-controller";
-import { refreshNotificationsJob } from "./jobs/integrations/notifications";
-import { timetableJob } from "./jobs/integrations/timetable";
-import { tracearrJob } from "./jobs/integrations/tracearr";
-import { umamiActiveVisitorsJob } from "./jobs/integrations/umami";
-import { vpnJob } from "./jobs/integrations/vpn";
-import { minecraftServerStatusJob } from "./jobs/minecraft-server-status";
 import { pingJob } from "./jobs/ping";
-import { rssFeedsJob } from "./jobs/rss-feeds";
-import { updateCheckerJob } from "./jobs/update-checker";
-import { weatherJob } from "./jobs/weather";
 import { createCronJobGroup } from "./lib";
 
 const getJobGroup = () => {
@@ -34,35 +8,9 @@ const getJobGroup = () => {
     analytics: analyticsJob,
     iconsUpdater: iconsUpdaterJob,
     ping: pingJob,
-    smartHomeEntityState: smartHomeEntityStateJob,
-    mediaServer: mediaServerJob,
-    mediaOrganizer: mediaOrganizerJob,
-    downloads: downloadsJob,
-    dnsHole: dnsHoleJob,
-    mediaRequestStats: mediaRequestStatsJob,
-    mediaRequestList: mediaRequestListJob,
-    rssFeeds: rssFeedsJob,
-    indexerManager: indexerManagerJob,
-    healthMonitoring: healthMonitoringJob,
-    updateChecker: updateCheckerJob,
-    mediaTranscoding: mediaTranscodingJob,
-    minecraftServerStatus: minecraftServerStatusJob,
-    dockerContainers: dockerContainersJob,
-    networkController: networkControllerJob,
-    firewallCpu: firewallCpuJob,
-    firewallMemory: firewallMemoryJob,
-    firewallVersion: firewallVersionJob,
-    firewallInterfaces: firewallInterfacesJob,
-    refreshNotifications: refreshNotificationsJob,
-    weather: weatherJob,
-    timetable: timetableJob,
-    tracearr: tracearrJob,
-    umamiActiveVisitors: umamiActiveVisitorsJob,
-    vpn: vpnJob,
   });
 };
 
-// Add global type augmentation for homarr
 declare global {
   var cronJobs: ReturnType<typeof getJobGroup> | undefined;
 }

packages/cron-jobs/src/jobs/docker.ts

@@ -1,31 +0,0 @@
-import SuperJSON from "superjson";
-
-import { createLogger } from "@homarr/core/infrastructure/logs";
-import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
-import { EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
-import { db, eq } from "@homarr/db";
-import { items } from "@homarr/db/schema";
-import { dockerContainersRequestHandler } from "@homarr/request-handler/docker";
-
-import type { WidgetComponentProps } from "../../../widgets";
-import { createCronJob } from "../lib";
-
-const logger = createLogger({ module: "dockerJobs" });
-
-export const dockerContainersJob = createCronJob("dockerContainers", EVERY_MINUTE).withCallback(async () => {
-  const dockerItems = await db.query.items.findMany({
-    where: eq(items.kind, "dockerContainers"),
-  });
-
-  await Promise.allSettled(
-    dockerItems.map(async (item) => {
-      try {
-        const options = SuperJSON.parse<WidgetComponentProps<"dockerContainers">["options"]>(item.options);
-        const innerHandler = dockerContainersRequestHandler.handler(options);
-        await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: true });
-      } catch (error) {
-        logger.error(new ErrorWithMetadata("Failed to update Docker container status", { item }, { cause: error }));
-      }
-    }),
-  );
-});

packages/cron-jobs/src/jobs/integrations/dns-hole.ts

@@ -1,15 +0,0 @@
-import { EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
-import { dnsHoleRequestHandler } from "@homarr/request-handler/dns-hole";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-
-import { createCronJob } from "../../lib";
-
-export const dnsHoleJob = createCronJob("dnsHole", EVERY_MINUTE).withCallback(
-  createRequestIntegrationJobHandler(dnsHoleRequestHandler.handler, {
-    widgetKinds: ["dnsHoleSummary", "dnsHoleControls"],
-    getInput: {
-      dnsHoleSummary: () => ({}),
-      dnsHoleControls: () => ({}),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/downloads.ts

@@ -1,16 +0,0 @@
-import { EVERY_5_SECONDS } from "@homarr/cron-jobs-core/expressions";
-import { downloadClientRequestHandler } from "@homarr/request-handler/downloads";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-
-import { createCronJob } from "../../lib";
-
-export const downloadsJob = createCronJob("downloads", EVERY_5_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(downloadClientRequestHandler.handler, {
-    widgetKinds: ["downloads"],
-    getInput: {
-      downloads: (options) => ({
-        limit: options.limitPerIntegration,
-      }),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/firewall.ts

@@ -1,46 +0,0 @@
-import { EVERY_5_SECONDS, EVERY_30_SECONDS, EVERY_HOUR, EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
-import {
-  firewallCpuRequestHandler,
-  firewallInterfacesRequestHandler,
-  firewallMemoryRequestHandler,
-  firewallVersionRequestHandler,
-} from "@homarr/request-handler/firewall";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-
-import { createCronJob } from "../../lib";
-
-export const firewallCpuJob = createCronJob("firewallCpu", EVERY_5_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(firewallCpuRequestHandler.handler, {
-    widgetKinds: ["firewall"],
-    getInput: {
-      firewall: () => ({}),
-    },
-  }),
-);
-
-export const firewallMemoryJob = createCronJob("firewallMemory", EVERY_MINUTE).withCallback(
-  createRequestIntegrationJobHandler(firewallMemoryRequestHandler.handler, {
-    widgetKinds: ["firewall"],
-    getInput: {
-      firewall: () => ({}),
-    },
-  }),
-);
-
-export const firewallInterfacesJob = createCronJob("firewallInterfaces", EVERY_30_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(firewallInterfacesRequestHandler.handler, {
-    widgetKinds: ["firewall"],
-    getInput: {
-      firewall: () => ({}),
-    },
-  }),
-);
-
-export const firewallVersionJob = createCronJob("firewallVersion", EVERY_HOUR).withCallback(
-  createRequestIntegrationJobHandler(firewallVersionRequestHandler.handler, {
-    widgetKinds: ["firewall"],
-    getInput: {
-      firewall: () => ({}),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/health-monitoring.ts

@@ -1,33 +0,0 @@
-import { EVERY_5_SECONDS } from "@homarr/cron-jobs-core/expressions";
-import { coolifyRequestHandler } from "@homarr/request-handler/coolify";
-import { clusterInfoRequestHandler, systemInfoRequestHandler } from "@homarr/request-handler/health-monitoring";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-
-import { createCronJob } from "../../lib";
-
-export const healthMonitoringJob = createCronJob("healthMonitoring", EVERY_5_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(
-    (integration, itemOptions: Record<string, never>) => {
-      const { kind } = integration;
-
-      if (kind === "beszel") {
-        return null as never;
-      }
-      if (kind !== "proxmox" && kind !== "mock" && kind !== "coolify") {
-        return systemInfoRequestHandler.handler({ ...integration, kind }, itemOptions);
-      }
-      if (kind === "coolify") {
-        return coolifyRequestHandler.handler({ ...integration, kind }, itemOptions);
-      }
-      return clusterInfoRequestHandler.handler({ ...integration, kind }, itemOptions);
-    },
-    {
-      widgetKinds: ["healthMonitoring", "systemResources", "coolify"],
-      getInput: {
-        healthMonitoring: () => ({}),
-        systemResources: () => ({}),
-        coolify: () => ({}),
-      },
-    },
-  ),
-);

packages/cron-jobs/src/jobs/integrations/home-assistant.ts

@@ -1,16 +0,0 @@
-import { EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-import { smartHomeEntityStateRequestHandler } from "@homarr/request-handler/smart-home-entity-state";
-
-import { createCronJob } from "../../lib";
-
-export const smartHomeEntityStateJob = createCronJob("smartHomeEntityState", EVERY_MINUTE).withCallback(
-  createRequestIntegrationJobHandler(smartHomeEntityStateRequestHandler.handler, {
-    widgetKinds: ["smartHome-entityState"],
-    getInput: {
-      "smartHome-entityState": (options) => ({
-        entityId: options.entityId,
-      }),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/indexer-manager.ts

@@ -1,14 +0,0 @@
-import { EVERY_5_MINUTES } from "@homarr/cron-jobs-core/expressions";
-import { indexerManagerRequestHandler } from "@homarr/request-handler/indexer-manager";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-
-import { createCronJob } from "../../lib";
-
-export const indexerManagerJob = createCronJob("indexerManager", EVERY_5_MINUTES).withCallback(
-  createRequestIntegrationJobHandler(indexerManagerRequestHandler.handler, {
-    widgetKinds: ["indexerManager"],
-    getInput: {
-      indexerManager: () => ({}),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/media-organizer.ts

@@ -1,36 +0,0 @@
-import dayjs from "dayjs";
-
-import { EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
-import { calendarMonthRequestHandler } from "@homarr/request-handler/calendar";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-
-import { createCronJob } from "../../lib";
-
-export const mediaOrganizerJob = createCronJob("mediaOrganizer", EVERY_MINUTE).withCallback(
-  createRequestIntegrationJobHandler(calendarMonthRequestHandler.handler, {
-    widgetKinds: ["calendar"],
-    getInput: {
-      // Request handler will run for all specified months
-      calendar: (options) => {
-        const inputs = [];
-
-        const startOffset = -Number(options.filterPastMonths);
-        const endOffset = Number(options.filterFutureMonths);
-
-        for (let offsetMonths = startOffset; offsetMonths <= endOffset; offsetMonths++) {
-          const year = dayjs().subtract(offsetMonths, "months").year();
-          const month = dayjs().subtract(offsetMonths, "months").month();
-
-          inputs.push({
-            year,
-            month,
-            releaseType: options.releaseType,
-            showUnmonitored: options.showUnmonitored,
-          });
-        }
-
-        return inputs;
-      },
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/media-requests.ts

@@ -1,24 +0,0 @@
-import { EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-import { mediaRequestListRequestHandler } from "@homarr/request-handler/media-request-list";
-import { mediaRequestStatsRequestHandler } from "@homarr/request-handler/media-request-stats";
-
-import { createCronJob } from "../../lib";
-
-export const mediaRequestStatsJob = createCronJob("mediaRequestStats", EVERY_MINUTE).withCallback(
-  createRequestIntegrationJobHandler(mediaRequestStatsRequestHandler.handler, {
-    widgetKinds: ["mediaRequests-requestStats"],
-    getInput: {
-      "mediaRequests-requestStats": () => ({}),
-    },
-  }),
-);
-
-export const mediaRequestListJob = createCronJob("mediaRequestList", EVERY_MINUTE).withCallback(
-  createRequestIntegrationJobHandler(mediaRequestListRequestHandler.handler, {
-    widgetKinds: ["mediaRequests-requestList"],
-    getInput: {
-      "mediaRequests-requestList": () => ({}),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/media-server.ts

@@ -1,14 +0,0 @@
-import { EVERY_5_SECONDS } from "@homarr/cron-jobs-core/expressions";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-import { mediaServerRequestHandler } from "@homarr/request-handler/media-server";
-
-import { createCronJob } from "../../lib";
-
-export const mediaServerJob = createCronJob("mediaServer", EVERY_5_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(mediaServerRequestHandler.handler, {
-    widgetKinds: ["mediaServer"],
-    getInput: {
-      mediaServer: ({ showOnlyPlaying }) => ({ showOnlyPlaying }),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/media-transcoding.ts

@@ -1,14 +0,0 @@
-import { EVERY_5_MINUTES } from "@homarr/cron-jobs-core/expressions";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-import { mediaTranscodingRequestHandler } from "@homarr/request-handler/media-transcoding";
-
-import { createCronJob } from "../../lib";
-
-export const mediaTranscodingJob = createCronJob("mediaTranscoding", EVERY_5_MINUTES).withCallback(
-  createRequestIntegrationJobHandler(mediaTranscodingRequestHandler.handler, {
-    widgetKinds: ["mediaTranscoding"],
-    getInput: {
-      mediaTranscoding: () => ({ pageOffset: 0, pageSize: 10 }),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/network-controller.ts

@@ -1,14 +0,0 @@
-import { EVERY_MINUTE } from "@homarr/cron-jobs-core/expressions";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-import { networkControllerRequestHandler } from "@homarr/request-handler/network-controller";
-
-import { createCronJob } from "../../lib";
-
-export const networkControllerJob = createCronJob("networkController", EVERY_MINUTE).withCallback(
-  createRequestIntegrationJobHandler(networkControllerRequestHandler.handler, {
-    widgetKinds: ["networkControllerSummary"],
-    getInput: {
-      networkControllerSummary: () => ({}),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/notifications.ts

@@ -1,14 +0,0 @@
-import { EVERY_5_MINUTES } from "@homarr/cron-jobs-core/expressions";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-import { notificationsRequestHandler } from "@homarr/request-handler/notifications";
-
-import { createCronJob } from "../../lib";
-
-export const refreshNotificationsJob = createCronJob("refreshNotifications", EVERY_5_MINUTES).withCallback(
-  createRequestIntegrationJobHandler(notificationsRequestHandler.handler, {
-    widgetKinds: ["notifications"],
-    getInput: {
-      notifications: (options) => options,
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/timetable.ts

@@ -1,39 +0,0 @@
-import SuperJSON from "superjson";
-
-import { createLogger } from "@homarr/core/infrastructure/logs";
-import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
-import { EVERY_5_MINUTES } from "@homarr/cron-jobs-core/expressions";
-import { db, eq } from "@homarr/db";
-import { items } from "@homarr/db/schema";
-import { timetableGetTimetableRequestHandler } from "@homarr/request-handler/timetable";
-
-import type { WidgetComponentProps } from "../../../../widgets";
-import { createCronJob } from "../../lib";
-
-const logger = createLogger({ module: "timetableJobs" });
-
-export const timetableJob = createCronJob("timetable", EVERY_5_MINUTES).withCallback(async () => {
-  const timetableItems = await db.query.items.findMany({
-    where: eq(items.kind, "timetable"),
-  });
-
-  const parsedItems = timetableItems.map((item) => ({
-    id: item.id,
-    options: SuperJSON.parse<WidgetComponentProps<"timetable">["options"]>(item.options),
-  }));
-
-  for (const item of parsedItems) {
-    if (!item.options.station) continue;
-
-    try {
-      const innerHandler = timetableGetTimetableRequestHandler.handler({
-        baseUrl: item.options.baseUrl,
-        stationId: item.options.station.value,
-        limit: 10,
-      });
-      await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: true });
-    } catch (error) {
-      logger.error(new ErrorWithMetadata("Failed to update timetable", { id: item.id }, { cause: error }));
-    }
-  }
-});

packages/cron-jobs/src/jobs/integrations/tracearr.ts

@@ -1,14 +0,0 @@
-import { EVERY_5_SECONDS } from "@homarr/cron-jobs-core/expressions";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-import { tracearrRequestHandler } from "@homarr/request-handler/tracearr";
-
-import { createCronJob } from "../../lib";
-
-export const tracearrJob = createCronJob("tracearr", EVERY_5_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(tracearrRequestHandler.handler, {
-    widgetKinds: ["tracearr"],
-    getInput: {
-      tracearr: () => ({}),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/umami.ts

@@ -1,14 +0,0 @@
-import { EVERY_30_SECONDS } from "@homarr/cron-jobs-core/expressions";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-import { umamiActiveVisitorsRequestHandler } from "@homarr/request-handler/umami";
-
-import { createCronJob } from "../../lib";
-
-export const umamiActiveVisitorsJob = createCronJob("umamiActiveVisitors", EVERY_30_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(umamiActiveVisitorsRequestHandler.handler, {
-    widgetKinds: ["umami"],
-    getInput: {
-      umami: (options) => (options.websiteId ? { websiteId: options.websiteId } : []),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/integrations/vpn.ts

@@ -1,14 +0,0 @@
-import { EVERY_30_SECONDS } from "@homarr/cron-jobs-core/expressions";
-import { vpnSummaryHandler } from "@homarr/request-handler/vpn";
-import { createRequestIntegrationJobHandler } from "@homarr/request-handler/lib/cached-request-integration-job-handler";
-
-import { createCronJob } from "../../lib";
-
-export const vpnJob = createCronJob("vpn", EVERY_30_SECONDS).withCallback(
-  createRequestIntegrationJobHandler(vpnSummaryHandler.handler, {
-    widgetKinds: ["vpn"],
-    getInput: {
-      vpn: () => ({}),
-    },
-  }),
-);

packages/cron-jobs/src/jobs/minecraft-server-status.ts

@@ -1,25 +0,0 @@
-import SuperJSON from "superjson";
-
-import { EVERY_5_MINUTES } from "@homarr/cron-jobs-core/expressions";
-import { db, eq } from "@homarr/db";
-import { items } from "@homarr/db/schema";
-import { minecraftServerStatusRequestHandler } from "@homarr/request-handler/minecraft-server-status";
-
-import type { WidgetComponentProps } from "../../../widgets/src";
-import { createCronJob } from "../lib";
-
-export const minecraftServerStatusJob = createCronJob("minecraftServerStatus", EVERY_5_MINUTES).withCallback(
-  async () => {
-    const dbItems = await db.query.items.findMany({
-      where: eq(items.kind, "minecraftServerStatus"),
-    });
-
-    await Promise.allSettled(
-      dbItems.map(async (item) => {
-        const options = SuperJSON.parse<WidgetComponentProps<"minecraftServerStatus">["options"]>(item.options);
-        const innerHandler = minecraftServerStatusRequestHandler.handler(options);
-        await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: true });
-      }),
-    );
-  },
-);

packages/cron-jobs/src/jobs/rss-feeds.ts

@@ -1,39 +0,0 @@
-import SuperJSON from "superjson";
-
-import { createLogger } from "@homarr/core/infrastructure/logs";
-import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
-import { EVERY_10_MINUTES } from "@homarr/cron-jobs-core/expressions";
-import { db, eq } from "@homarr/db";
-import { items } from "@homarr/db/schema";
-import { rssFeedsRequestHandler } from "@homarr/request-handler/rss-feeds";
-
-// This import is done that way to avoid circular dependencies.
-import type { WidgetComponentProps } from "../../../widgets";
-import { createCronJob } from "../lib";
-
-const logger = createLogger({ module: "rssFeedsJobs" });
-
-export const rssFeedsJob = createCronJob("rssFeeds", EVERY_10_MINUTES).withCallback(async () => {
-  const rssItems = await db.query.items.findMany({
-    where: eq(items.kind, "rssFeed"),
-  });
-
-  const itemOptions = rssItems.map((item) => SuperJSON.parse<WidgetComponentProps<"rssFeed">["options"]>(item.options));
-
-  for (const option of itemOptions) {
-    const maxAmountPosts = typeof option.maximumAmountPosts === "number" ? option.maximumAmountPosts : 100;
-    for (const url of option.feedUrls) {
-      try {
-        const innerHandler = rssFeedsRequestHandler.handler({
-          url,
-          count: maxAmountPosts,
-        });
-        await innerHandler.getCachedOrUpdatedDataAsync({
-          forceUpdate: true,
-        });
-      } catch (error) {
-        logger.error(new ErrorWithMetadata("Failed to update RSS feed", { url }, { cause: error }));
-      }
-    }
-  }
-});

packages/cron-jobs/src/jobs/update-checker.ts

@@ -1,11 +0,0 @@
-import { EVERY_DAY } from "@homarr/cron-jobs-core/expressions";
-import { updateCheckerRequestHandler } from "@homarr/request-handler/update-checker";
-
-import { createCronJob } from "../lib";
-
-export const updateCheckerJob = createCronJob("updateChecker", EVERY_DAY, {
-  runOnStart: true,
-}).withCallback(async () => {
-  const handler = updateCheckerRequestHandler.handler({});
-  await handler.getCachedOrUpdatedDataAsync({});
-});

packages/cron-jobs/src/jobs/weather.ts

@@ -1,36 +0,0 @@
-import SuperJSON from "superjson";
-
-import { createLogger } from "@homarr/core/infrastructure/logs";
-import { ErrorWithMetadata } from "@homarr/core/infrastructure/logs/error";
-import { EVERY_10_MINUTES } from "@homarr/cron-jobs-core/expressions";
-import { db, eq } from "@homarr/db";
-import { items } from "@homarr/db/schema";
-import { weatherRequestHandler } from "@homarr/request-handler/weather";
-
-import type { WidgetComponentProps } from "../../../widgets";
-import { createCronJob } from "../lib";
-
-const logger = createLogger({ module: "weatherJobs" });
-
-export const weatherJob = createCronJob("weather", EVERY_10_MINUTES).withCallback(async () => {
-  const weatherItems = await db.query.items.findMany({
-    where: eq(items.kind, "weather"),
-  });
-
-  const parsedItems = weatherItems.map((item) => ({
-    id: item.id,
-    options: SuperJSON.parse<WidgetComponentProps<"weather">["options"]>(item.options),
-  }));
-
-  for (const item of parsedItems) {
-    try {
-      const innerHandler = weatherRequestHandler.handler({
-        longitude: item.options.location.longitude,
-        latitude: item.options.location.latitude,
-      });
-      await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: true });
-    } catch (error) {
-      logger.error(new ErrorWithMetadata("Failed to update weather", { id: item.id }, { cause: error }));
-    }
-  }
-});

packages/forms-collection/src/icon-picker/icon-picker.tsx

@@ -55,8 +55,6 @@ export const IconPicker = ({
   const [value, setValue] = useUncontrolled({ value: propsValue, onChange });
   const [query, setQuery] = useState("");
 
-  // ponytail: reset the typed query when the committed value changes
-  // externally (form reset, parent re-render) so the input reverts to the URL.
   useEffect(() => {
     setQuery("");
   }, [value]);
@@ -65,13 +63,8 @@ export const IconPicker = ({
   const tCommon = useScopedI18n("common");
   const [debouncedQuery] = useDebouncedValue(query, 100);
 
-  // ponytail: only search when the typed query differs from the committed
-  // value. On mount the input shows the existing URL (edit mode), which
-  // would never match the bare filenames in the icon table.
   const searchText = (debouncedQuery !== (value ?? "") && debouncedQuery) || "";
 
-  // ponytail: not useSuspenseQuery — an above Suspense boundary would
-  // trigger on every keystroke and the dropdown flash is bad UX.
   const { data, isLoading, isError, refetch } = clientApi.icon.findIcons.useQuery(
     { searchText },
     { placeholderData: (prev) => prev },
@@ -123,11 +116,8 @@ export const IconPicker = ({
     );
   });
 
-  // ponytail: show the typed query if non-empty, else fall back to the URL.
   const inputValue = query || value || "";
-  // ponytail: show the existing icon as a left-section preview.
   const leftSection = shouldShowPreview(value) && <img src={value} alt="" style={{ width: 20, height: 20 }} />;
-  // ponytail: prop override -> real count -> loading text.
   const placeholderText =
     placeholder ||
     (data && tCommon("iconPicker.header", { countIcons: String(data.countIcons) })) ||

packages/integrations/src/beszel/beszel-integration.ts

@@ -13,13 +13,11 @@ import type {
   BeszelAlertHistory,
   BeszelAuthResponse,
   BeszelContainer,
-  BeszelContainerStats,
   BeszelContainerStatsRecord,
   BeszelSmartDevice,
   BeszelSystem,
   BeszelSystemDetails,
   BeszelSystemdService,
-  BeszelSystemStats,
   BeszelSystemStatsRecord,
   CreateAlertInput,
   PocketBaseListResponse,
@@ -286,111 +284,6 @@ export class BeszelIntegration extends Integration {
     });
   }
 
-  public async subscribeRealtimeMetrics(
-    systemId: string,
-    onMessage: (data: { stats: BeszelSystemStatsRecord; containerStats: BeszelContainerStatsRecord | null }) => void,
-    signal: AbortSignal,
-  ): Promise<void> {
-    const session = await this.authenticateAsync();
-    const sseUrl = this.url("/api/realtime");
-    logger.debug("Opening Beszel SSE connection", { integrationId: this.integration.id, systemId });
-
-    const sseResponse = await fetchWithTrustedCertificatesAsync(sseUrl, {
-      headers: { Authorization: session.token },
-      signal,
-    });
-
-    if (!sseResponse.ok || !sseResponse.body) {
-      logger.warn("Beszel SSE connection failed", {
-        integrationId: this.integration.id,
-        systemId,
-        status: sseResponse.status,
-      });
-      throw new ResponseError(sseResponse);
-    }
-    logger.debug("Beszel SSE connection opened", { integrationId: this.integration.id, systemId });
-
-    const reader = sseResponse.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let clientId: string | null = null;
-
-    const processLine = (line: string) => {
-      if (!line.startsWith("data:")) return;
-      const jsonStr = line.slice(5).trim();
-      if (!jsonStr) return;
-
-      try {
-        const parsed = JSON.parse(jsonStr) as Record<string, unknown>;
-
-        if (!clientId && typeof parsed.clientId === "string") {
-          clientId = parsed.clientId;
-          this.subscribeTopic(clientId, systemId, session.token).catch((err) => {
-            logger.warn("Failed to subscribe to rt_metrics topic, aborting SSE", { error: err });
-            reader.cancel().catch(() => {});
-          });
-          return;
-        }
-
-        if ("stats" in parsed) {
-          const now = new Date().toISOString();
-          const envelope = { id: "", system: systemId, type: "1m" as const, created: now, updated: now };
-          const stats: BeszelSystemStatsRecord = { ...envelope, stats: parsed.stats as BeszelSystemStats };
-
-          let containerStats: BeszelContainerStatsRecord | null = null;
-          const hasContainers =
-            parsed.container &&
-            Array.isArray(parsed.container) &&
-            (parsed.container as BeszelContainerStats[]).length > 0;
-          if (hasContainers) {
-            containerStats = { ...envelope, stats: parsed.container as BeszelContainerStats[] };
-          }
-          onMessage({ stats, containerStats });
-        }
-      } catch {
-        logger.debug("Failed to parse SSE message", { line });
-      }
-    };
-
-    try {
-      while (!signal.aborted) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop() ?? "";
-        for (const line of lines) {
-          processLine(line);
-        }
-      }
-      if (!signal.aborted) {
-        logger.warn("Beszel SSE stream ended unexpectedly", {
-          integrationId: this.integration.id,
-          systemId,
-        });
-        throw new Error("Beszel SSE stream ended unexpectedly");
-      }
-    } finally {
-      reader.cancel().catch(() => {});
-    }
-  }
-
-  private async subscribeTopic(clientId: string, systemId: string, token: string): Promise<void> {
-    const topic = `rt_metrics?options=${JSON.stringify({ query: { system: systemId } })}`;
-    const response = await fetchWithTrustedCertificatesAsync(this.url("/api/realtime"), {
-      method: "POST",
-      headers: {
-        Authorization: token,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ clientId, subscriptions: [topic] }),
-    });
-    if (!response.ok) {
-      throw new ResponseError(response);
-    }
-  }
-
   protected async testingAsync(input: IntegrationTestingInput): Promise<TestingResult> {
     const response = await input.fetchAsync(this.url("/api/collections/users/auth-with-password"), {
       method: "POST",

packages/redis/src/index.ts

@@ -1,42 +1,22 @@
 import type { LogLevel } from "@homarr/core/infrastructure/logs/constants";
 
-import { createListChannel, createQueueChannel, createSubPubChannel } from "./lib/channel";
+import { createListChannel, createSubPubChannel } from "./lib/channel";
 
 export {
-  createCacheChannel,
-  createItemAndIntegrationChannel,
-  createItemChannel,
-  createIntegrationOptionsChannel,
-  createWidgetOptionsChannel,
-  createChannelWithLatestAndEvents,
-  createChannelEventHistory,
   handshakeAsync,
   createSubPubChannel,
   createGetSetChannel,
-  createQueryCacheChannel,
-  getAllQueryCacheAsync,
+  setQueryCacheAsync,
+  getQueryCacheAsync,
+  removeQueryCacheAsync,
   invalidateIntegrationCacheAsync,
 } from "./lib/channel";
 
-export { createIntegrationHistoryChannel } from "./lib/channels/history-channel";
-
-export const exampleChannel = createSubPubChannel<{ message: string }>("example");
 export const pingChannel = createSubPubChannel<
   { url: string; statusCode: number; durationMs: number } | { url: string; error: string }
 >("ping");
 export const pingUrlChannel = createListChannel<string>("ping-url");
 
-export const homeAssistantEntityState = createSubPubChannel<{
-  entityId: string;
-  state: string;
-}>("home-assistant/entity-state");
-
-export const queueChannel = createQueueChannel<{
-  name: string;
-  executionDate: Date;
-  data: unknown;
-}>("common-queue");
-
 export interface LoggerMessage {
   message: string;
   level: LogLevel;

packages/redis/src/lib/channel.ts

@@ -1,8 +1,7 @@
 import superjson from "superjson";
 
-import { createId, hashObjectBase64 } from "@homarr/common";
+import { createId } from "@homarr/common";
 import { createLogger } from "@homarr/core/infrastructure/logs";
-import type { WidgetKind } from "@homarr/definitions";
 
 import { ChannelSubscriptionTracker } from "./channel-subscription-tracker";
 import { createRedisConnection } from "./connection";
@@ -129,218 +128,38 @@ export const createGetSetChannel = <TData>(name: string) => {
   };
 };
 
-interface QueryCacheChannelOptions {
-  userId: string;
-  boardId: string;
-  key: string;
-  ttlMs: number;
-  maxValueBytes: number;
-}
+const queryCacheKey = (userId: string, boardId: string) => `qc:${userId}:${boardId}`;
 
-const queryCacheHashKey = (userId: string, boardId: string) => `qc:${userId}:${boardId}`;
-
-export const createQueryCacheChannel = ({ userId, boardId, key, ttlMs, maxValueBytes }: QueryCacheChannelOptions) => {
-  const hkey = queryCacheHashKey(userId, boardId);
-
-  return {
-    name: `${hkey}:${key}`,
-    getAsync: async () => {
-      return await getSetClient.hget(hkey, key);
-    },
-    setAsync: async (value: string) => {
+export const setQueryCacheAsync = async (
+  userId: string,
+  boardId: string,
+  value: string,
+  ttlMs: number,
+  maxValueBytes: number,
+) => {
   if (Buffer.byteLength(value, "utf8") > maxValueBytes) {
     logger.warn("Query cache value exceeded maximum size", {
-          channel: hkey,
+      key: queryCacheKey(userId, boardId),
       valueBytes: Buffer.byteLength(value, "utf8"),
       maxValueBytes,
     });
     return false;
   }
-
-      await getSetClient.hset(hkey, key, value);
-      await getSetClient.pexpire(hkey, ttlMs);
+  await getSetClient.set(queryCacheKey(userId, boardId), value, "PX", ttlMs);
   return true;
-    },
-    removeAsync: async () => {
-      await getSetClient.hdel(hkey, key);
-    },
-  };
 };
 
-export const getAllQueryCacheAsync = async (userId: string, boardId: string): Promise<Record<string, string>> => {
-  const hkey = queryCacheHashKey(userId, boardId);
-  return await getSetClient.hgetall(hkey);
+export const getQueryCacheAsync = async (userId: string, boardId: string) =>
+  await getSetClient.get(queryCacheKey(userId, boardId));
+
+export const removeQueryCacheAsync = async (userId: string, boardId: string) => {
+  await getSetClient.del(queryCacheKey(userId, boardId));
 };
 
-/**
- * Creates a new cache channel.
- * @param name name of the channel
- * @param cacheDurationMs duration in milliseconds to cache
- * @returns cache channel object
- */
-export const createCacheChannel = <TData>(name: string, cacheDurationMs: number = 5 * 60 * 1000) => {
-  const cacheChannelName = `cache:${name}`;
-
-  return {
-    /**
-     * Get the data from the cache channel.
-     * @returns data or null if not found or expired
-     */
-    getAsync: async () => {
-      const data = await getSetClient.get(cacheChannelName);
-      if (!data) return null;
-
-      const parsedData = superjson.parse<{ data: TData; timestamp: Date }>(data);
-      const now = new Date();
-      const diff = now.getTime() - parsedData.timestamp.getTime();
-      if (diff > cacheDurationMs) return null;
-
-      return parsedData;
-    },
-    /**
-     * Consume the data from the cache channel, if not present or expired, it will call the callback to get new data.
-     * @param callback callback function to get new data if not present or expired
-     * @returns data or new data if not present or expired
-     */
-    consumeAsync: async (callback: () => Promise<TData>) => {
-      const data = await getSetClient.get(cacheChannelName);
-
-      const getNewDataAsync = async () => {
-        logger.debug(`Cache miss for channel '${cacheChannelName}'`);
-        const newData = await callback();
-        const result = { data: newData, timestamp: new Date() };
-        await getSetClient.set(cacheChannelName, superjson.stringify(result));
-        logger.debug(`Cache updated for channel '${cacheChannelName}'`);
-        return result;
-      };
-
-      if (!data) {
-        return await getNewDataAsync();
-      }
-
-      const parsedData = superjson.parse<{ data: TData; timestamp: Date }>(data);
-      const now = new Date();
-      const diff = now.getTime() - parsedData.timestamp.getTime();
-
-      if (diff > cacheDurationMs) {
-        return await getNewDataAsync();
-      }
-
-      logger.debug(`Cache hit for channel '${cacheChannelName}'`);
-
-      return parsedData;
-    },
-    /**
-     * Invalidate the cache channels data.
-     */
-    invalidateAsync: async () => {
-      await getSetClient.del(cacheChannelName);
-    },
-    /**
-     * Set the data in the cache channel.
-     * @param data data to be stored in the cache channel
-     */
-    setAsync: async (data: TData) => {
-      await getSetClient.set(cacheChannelName, superjson.stringify({ data, timestamp: new Date() }));
-    },
-  };
-};
-
-export const createItemAndIntegrationChannel = <TData>(kind: WidgetKind, integrationId: string) => {
-  const channelName = `item:${kind}:integration:${integrationId}`;
-  return createChannelWithLatestAndEvents<TData>(channelName);
-};
-
-export const createIntegrationOptionsChannel = <TData>(
-  integrationId: string,
-  queryKey: string,
-  options: Record<string, unknown>,
-) => {
-  const optionsKey = hashObjectBase64(options);
-  const channelName = `integration:${integrationId}:${queryKey}:options:${optionsKey}`;
-  return createChannelWithLatestAndEvents<TData>(channelName);
-};
-
-/**
- * Invalidates all cached data for a given integration by deleting every Redis key
- * that starts with `integration:${integrationId}:` as well as the integration's
- * session store entry. This ensures that stale data from a misconfigured or
- * updated integration is never served from cache.
- */
 export const invalidateIntegrationCacheAsync = async (integrationId: string): Promise<void> => {
   const client = getSetClient as typeof getSetClient | null;
-  if (!client) {
-    return;
-  }
-
-  const patterns = [`integration:${integrationId}:*`, `session-store:${integrationId}`];
-  let deletedCount = 0;
-  for (const pattern of patterns) {
-    let cursor = "0";
-    do {
-      const [nextCursor, keys] = await client.scan(cursor, "MATCH", pattern, "COUNT", 200);
-      cursor = nextCursor;
-      if (keys.length > 0) {
-        await client.del(...keys);
-        deletedCount += keys.length;
-      }
-    } while (cursor !== "0");
-  }
-  if (deletedCount > 0) {
-    logger.info("Invalidated integration cache", { integrationId, deletedKeys: deletedCount });
-  }
-};
-
-export const createWidgetOptionsChannel = <TData>(
-  widgetKind: WidgetKind,
-  queryKey: string,
-  options: Record<string, unknown>,
-) => {
-  const optionsKey = hashObjectBase64(options);
-  const channelName = `widget:${widgetKind}:${queryKey}:options:${optionsKey}`;
-  return createChannelWithLatestAndEvents<TData>(channelName);
-};
-
-export const createItemChannel = <TData>(itemId: string) => {
-  return createChannelWithLatestAndEvents<TData>(`item:${itemId}`);
-};
-
-export const createChannelEventHistory = <TData>(channelName: string, maxElements = 32) => {
-  return {
-    subscribe: (callback: (data: TData) => void) => {
-      return ChannelSubscriptionTracker.subscribe(channelName, (message) => {
-        callback(superjson.parse(message));
-      });
-    },
-    pushAsync: async (data: TData, options = { publish: false }) => {
-      if (options.publish) await publisher.publish(channelName, superjson.stringify(data));
-      await getSetClient.lpush(channelName, superjson.stringify({ data, timestamp: new Date() }));
-      await getSetClient.ltrim(channelName, 0, maxElements);
-    },
-    clearAsync: async () => {
-      await getSetClient.del(channelName);
-    },
-    /**
-     * Returns a slice of the available data in the channel.
-     * If any of the indexes are out of range (or -range), returned data will be clamped.
-     * @param startIndex Start index of the slice, negative values are counted from the end, defaults at beginning of range.
-     * @param endIndex End index of the slice, negative values are counted from the end, defaults at end of range.
-     */
-    getSliceAsync: async (startIndex = 0, endIndex = -1) => {
-      const range = await getSetClient.lrange(channelName, startIndex, endIndex);
-      return range.map((item) => superjson.parse<{ data: TData; timestamp: Date }>(item));
-    },
-    getSliceUntilTimeAsync: async (time: Date) => {
-      const itemsInCollection = await getSetClient.lrange(channelName, 0, -1);
-      return itemsInCollection
-        .map((item) => superjson.parse<{ data: TData; timestamp: Date }>(item))
-        .filter((item) => item.timestamp < time);
-    },
-    getLengthAsync: async () => {
-      return await getSetClient.llen(channelName);
-    },
-    name: channelName,
-  };
+  if (!client) return;
+  await client.del(`session-store:${integrationId}`);
 };
 
 /**
@@ -407,40 +226,6 @@ export const createChannelEventHistoryOld = <TData>(channelName: string, maxElem
   };
 };
 
-export const createChannelWithLatestAndEvents = <TData>(channelName: string) => {
-  return {
-    subscribe: (callback: (data: TData) => void) => {
-      return ChannelSubscriptionTracker.subscribe(channelName, (message) => {
-        callback(superjson.parse(message));
-      });
-    },
-    publishAndUpdateLastStateAsync: async (data: TData) => {
-      // Set first, then publish. If publish fails the storage is still consistent
-      // and subscribers will catch up on the next event.
-      const payload = superjson.stringify({ data, timestamp: new Date() });
-      await getSetClient.set(channelName, payload);
-      try {
-        await publisher.publish(channelName, superjson.stringify(data));
-      } catch (error) {
-        logger.warn("Failed to publish cache update (storage is correct, subscribers will catch up)", {
-          channel: channelName,
-          error: error instanceof Error ? error.message : String(error),
-        });
-      }
-    },
-    setAsync: async (data: TData) => {
-      await getSetClient.set(channelName, superjson.stringify({ data, timestamp: new Date() }));
-    },
-    getAsync: async () => {
-      const data = await getSetClient.get(channelName);
-      if (!data) return null;
-
-      return superjson.parse<{ data: TData; timestamp: Date }>(data);
-    },
-    name: channelName,
-  };
-};
-
 const queueClient = createRedisConnection();
 
 type WithId<TItem> = TItem & { _id: string };

packages/redis/src/lib/channels/history-channel.ts

@@ -1,6 +0,0 @@
-import { createChannelEventHistory } from "../channel";
-
-export const createIntegrationHistoryChannel = <TData>(integrationId: string, queryKey: string, maxElements = 32) => {
-  const channelName = `integration:${integrationId}:history:${queryKey}`;
-  return createChannelEventHistory<TData>(channelName, maxElements);
-};

packages/request-handler/src/anchor-notes.ts

@@ -1,30 +1,22 @@
-import dayjs from "dayjs";
-
 import type { AnchorNote, AnchorNotesListInput, AnchorNoteSummary } from "@homarr/integrations";
 import { createIntegrationAsync } from "@homarr/integrations";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const anchorNotesListRequestHandler = createCachedIntegrationRequestHandler<
+export const anchorNotesListRequestHandler = createIntegrationRequestHandler<
   AnchorNoteSummary[],
   "anchor",
   AnchorNotesListInput
 >({
-  queryKey: "anchorNotesList",
-  cacheDuration: dayjs.duration(15, "seconds"),
   async requestAsync(integration, input) {
     const instance = await createIntegrationAsync(integration);
     return instance.listNotesAsync(input);
   },
 });
 
-export const anchorNoteRequestHandler = createCachedIntegrationRequestHandler<AnchorNote, "anchor", { noteId: string }>(
-  {
-    queryKey: "anchorNote",
-    cacheDuration: dayjs.duration(15, "seconds"),
+export const anchorNoteRequestHandler = createIntegrationRequestHandler<AnchorNote, "anchor", { noteId: string }>({
   async requestAsync(integration, input) {
     const instance = await createIntegrationAsync(integration);
     return instance.getNoteAsync(input.noteId);
   },
-  },
-);
+});

packages/request-handler/src/archive-team-warrior.ts

@@ -1,12 +1,10 @@
-import dayjs from "dayjs";
-
 import type { IntegrationKindByCategory } from "@homarr/definitions";
 import type { ArchiveTeamWarriorStatus } from "@homarr/integrations";
 import { createIntegrationAsync } from "@homarr/integrations";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const archiveTeamWarriorRequestHandler = createCachedIntegrationRequestHandler<
+export const archiveTeamWarriorRequestHandler = createIntegrationRequestHandler<
   ArchiveTeamWarriorStatus,
   IntegrationKindByCategory<"archiving">,
   Record<string, never>
@@ -15,6 +13,4 @@ export const archiveTeamWarriorRequestHandler = createCachedIntegrationRequestHa
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getStatusAsync();
   },
-  cacheDuration: dayjs.duration(5, "minute"),
-  queryKey: "archiveTeamWarriorStatus",
 });

packages/request-handler/src/audiobookshelf.ts

@@ -1,11 +1,9 @@
-import dayjs from "dayjs";
-
 import { createIntegrationAsync } from "@homarr/integrations";
 import type { AudiobookshelfDashboardData } from "@homarr/integrations/types";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const audiobookshelfRequestHandler = createCachedIntegrationRequestHandler<
+export const audiobookshelfRequestHandler = createIntegrationRequestHandler<
   AudiobookshelfDashboardData,
   "audiobookshelf",
   Record<string, never>
@@ -14,6 +12,4 @@ export const audiobookshelfRequestHandler = createCachedIntegrationRequestHandle
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getDashboardDataAsync();
   },
-  cacheDuration: dayjs.duration(10, "minutes"),
-  queryKey: "audiobookshelfDashboard",
 });

packages/request-handler/src/beszel.ts

@@ -1,5 +1,3 @@
-import dayjs from "dayjs";
-
 import { createLogger } from "@homarr/core/infrastructure/logs";
 import { createIntegrationAsync } from "@homarr/integrations";
 import type {
@@ -12,7 +10,7 @@ import type {
   BeszelSystemStatsRecord,
 } from "@homarr/integrations/types";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
 const logger = createLogger({ module: "beszelRequestHandler" });
 
@@ -53,7 +51,7 @@ function mapToSystemRow(system: BeszelSystem, details: BeszelSystemDetails | nul
   };
 }
 
-export const beszelSystemsRequestHandler = createCachedIntegrationRequestHandler<
+export const beszelSystemsRequestHandler = createIntegrationRequestHandler<
   BeszelSystemRow[],
   "beszel" | "mock",
   Record<string, never>
@@ -64,7 +62,10 @@ export const beszelSystemsRequestHandler = createCachedIntegrationRequestHandler
     const systems = await instance.getSystemsAsync();
     const enriched = await Promise.all(
       systems.map(async (system) => {
-        const details = await instance.getSystemDetailsAsync(system.id).catch(() => null);
+        const details = await instance.getSystemDetailsAsync(system.id).catch((error) => {
+          logger.warn("Failed to fetch Beszel system details", { systemId: system.id, error: String(error) });
+          return null;
+        });
         return mapToSystemRow(system, details);
       }),
     );
@@ -75,10 +76,6 @@ export const beszelSystemsRequestHandler = createCachedIntegrationRequestHandler
     });
     return enriched;
   },
-  cacheDuration: dayjs.duration(1, "second"),
-  fallbackToStaleOnError: true,
-  retry: { attempts: 2, delayMs: 500 },
-  queryKey: "beszelSystems",
 });
 
 export interface BeszelAlertsData {
@@ -86,7 +83,7 @@ export interface BeszelAlertsData {
   history: BeszelAlertHistory[];
 }
 
-export const beszelAlertsRequestHandler = createCachedIntegrationRequestHandler<
+export const beszelAlertsRequestHandler = createIntegrationRequestHandler<
   BeszelAlertsData,
   "beszel" | "mock",
   { includeHistory: boolean; maxHistoryItems: number }
@@ -104,10 +101,6 @@ export const beszelAlertsRequestHandler = createCachedIntegrationRequestHandler<
     });
     return { alerts, history };
   },
-  cacheDuration: dayjs.duration(1, "second"),
-  fallbackToStaleOnError: true,
-  retry: { attempts: 2, delayMs: 500 },
-  queryKey: "beszelAlerts",
 });
 
 const timePeriodConfig: Record<string, { type: string; perPage: number }> = {
@@ -124,7 +117,7 @@ export interface BeszelStatsData {
   containerStats: BeszelContainerStatsRecord[];
 }
 
-export const beszelStatsRequestHandler = createCachedIntegrationRequestHandler<
+export const beszelStatsRequestHandler = createIntegrationRequestHandler<
   BeszelStatsData,
   "beszel" | "mock",
   { systemId: string; timePeriod: string; includeDocker: boolean }
@@ -135,7 +128,10 @@ export const beszelStatsRequestHandler = createCachedIntegrationRequestHandler<
     const instance = await createIntegrationAsync(integration);
     const systemStats = await instance.getSystemStatsAsync(input.systemId, config.type, config.perPage);
     const containerStats = input.includeDocker
-      ? await instance.getContainerStatsAsync(input.systemId, config.type, config.perPage).catch(() => [])
+      ? await instance.getContainerStatsAsync(input.systemId, config.type, config.perPage).catch((error) => {
+          logger.warn("Failed to fetch Beszel container stats", { systemId: input.systemId, error: String(error) });
+          return [];
+        })
       : [];
     logger.debug("beszelStats fetch completed", {
       integrationId: integration.id,
@@ -147,8 +143,4 @@ export const beszelStatsRequestHandler = createCachedIntegrationRequestHandler<
     });
     return { systemStats, containerStats };
   },
-  cacheDuration: dayjs.duration(1, "second"),
-  fallbackToStaleOnError: true,
-  retry: { attempts: 2, delayMs: 500 },
-  queryKey: "beszelStats",
 });

packages/request-handler/src/calendar.ts

@@ -4,9 +4,9 @@ import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
 import type { CalendarEvent, RadarrReleaseType } from "@homarr/integrations/types";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const calendarMonthRequestHandler = createCachedIntegrationRequestHandler<
+export const calendarMonthRequestHandler = createIntegrationRequestHandler<
   CalendarEvent[],
   IntegrationKindByCategory<"calendar">,
   { year: number; month: number; releaseType: RadarrReleaseType[]; showUnmonitored: boolean }
@@ -23,6 +23,4 @@ export const calendarMonthRequestHandler = createCachedIntegrationRequestHandler
       input.showUnmonitored,
     );
   },
-  cacheDuration: dayjs.duration(1, "minute"),
-  queryKey: "calendarMonth",
 });

packages/request-handler/src/coolify.ts

@@ -1,11 +1,9 @@
-import dayjs from "dayjs";
-
 import { createIntegrationAsync } from "@homarr/integrations";
 import type { CoolifyInstanceInfo } from "@homarr/integrations/types";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const coolifyRequestHandler = createCachedIntegrationRequestHandler<
+export const coolifyRequestHandler = createIntegrationRequestHandler<
   CoolifyInstanceInfo,
   "coolify",
   Record<string, never>
@@ -14,6 +12,4 @@ export const coolifyRequestHandler = createCachedIntegrationRequestHandler<
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getInstanceInfoAsync();
   },
-  cacheDuration: dayjs.duration(30, "seconds"),
-  queryKey: "coolifyInfo",
 });

packages/request-handler/src/dns-hole.ts

@@ -1,12 +1,10 @@
-import dayjs from "dayjs";
-
 import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
 import type { DnsHoleSummary } from "@homarr/integrations/types";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const dnsHoleRequestHandler = createCachedIntegrationRequestHandler<
+export const dnsHoleRequestHandler = createIntegrationRequestHandler<
   DnsHoleSummary,
   IntegrationKindByCategory<"dnsHole">,
   Record<string, never>
@@ -15,6 +13,4 @@ export const dnsHoleRequestHandler = createCachedIntegrationRequestHandler<
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getSummaryAsync();
   },
-  cacheDuration: dayjs.duration(5, "seconds"),
-  queryKey: "dnsHoleSummary",
 });

packages/request-handler/src/docker.ts

@@ -1,5 +1,4 @@
 import type { Readable } from "node:stream";
-import dayjs from "dayjs";
 import type { Container, ContainerInfo, ContainerStats } from "dockerode";
 import type Dockerode from "dockerode";
 
@@ -13,7 +12,7 @@ import type { ContainerState, Port } from "@homarr/docker";
 import { dockerLabels, DockerSingleton } from "@homarr/docker";
 
 import { createDockerLogStreamProcessor, decodeDockerLogs } from "./docker-log-decode";
-import { createCachedWidgetRequestHandler } from "./lib/cached-widget-request-handler";
+import { createWidgetRequestHandler } from "./lib/widget-request-handler";
 
 const logger = createLogger({ module: "dockerRequestHandler" });
 
@@ -171,16 +170,13 @@ const mockContainers: {
   },
 ];
 
-export const dockerContainersRequestHandler = createCachedWidgetRequestHandler({
-  queryKey: "dockerContainersResult",
-  widgetKind: "dockerContainers",
+export const dockerContainersRequestHandler = createWidgetRequestHandler({
   async requestAsync() {
     if (isDemoMode) {
       return mockContainers;
     }
     return await getContainersWithStatsAsync();
   },
-  cacheDuration: dayjs.duration(20, "seconds"),
 });
 
 const extractImage = (container: ContainerInfo) => extractContainerImageName(container.Image);

packages/request-handler/src/downloads.ts

@@ -1,12 +1,10 @@
-import dayjs from "dayjs";
-
 import type { IntegrationKindByCategory } from "@homarr/definitions";
 import type { DownloadClientJobsAndStatus } from "@homarr/integrations";
 import { createIntegrationAsync } from "@homarr/integrations";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const downloadClientRequestHandler = createCachedIntegrationRequestHandler<
+export const downloadClientRequestHandler = createIntegrationRequestHandler<
   DownloadClientJobsAndStatus,
   IntegrationKindByCategory<"downloadClient">,
   { limit: number }
@@ -15,6 +13,4 @@ export const downloadClientRequestHandler = createCachedIntegrationRequestHandle
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getClientJobsAndStatusAsync(input);
   },
-  cacheDuration: dayjs.duration(5, "seconds"),
-  queryKey: "downloadClientJobStatus",
 });

packages/request-handler/src/duckduckgo-bangs.ts

@@ -1,12 +1,10 @@
-import dayjs from "dayjs";
 import { z } from "zod";
 
 import { env } from "@homarr/common/env";
 import { ResponseError } from "@homarr/common/server";
 import { fetchWithTrustedCertificatesAsync } from "@homarr/core/infrastructure/http";
 import { withTimeoutAsync } from "@homarr/core/infrastructure/http/timeout";
-import { createChannelWithLatestAndEvents } from "@homarr/redis";
-import { createCachedRequestHandler } from "@homarr/request-handler/lib/cached-request-handler";
+import { createRequestHandler } from "@homarr/request-handler/lib/request-handler";
 
 export type DuckDuckGoBang = z.infer<typeof duckDuckGoBangSchema>;
 
@@ -38,9 +36,7 @@ const normalizeBangToken = (token: string) => token.toLowerCase().trim();
 
 const compareBangTokenAsc = (left: DuckDuckGoBang, right: DuckDuckGoBang) => left.t.localeCompare(right.t);
 
-export const duckDuckGoBangsRequestHandler = createCachedRequestHandler({
-  queryKey: "duckduckgo-bangs",
-  cacheDuration: dayjs.duration(1, "day"),
+export const duckDuckGoBangsRequestHandler = createRequestHandler({
   async requestAsync(_) {
     if (env.NO_EXTERNAL_CONNECTION) {
       return [];
@@ -73,7 +69,4 @@ export const duckDuckGoBangsRequestHandler = createCachedRequestHandler({
 
     return normalized;
   },
-  createRedisChannel() {
-    return createChannelWithLatestAndEvents<DuckDuckGoBang[]>("homarr:duckduckgo-bangs");
-  },
 });

packages/request-handler/src/firewall.ts

@@ -1,5 +1,3 @@
-import dayjs from "dayjs";
-
 import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
 import type {
@@ -9,9 +7,9 @@ import type {
   FirewallVersionSummary,
 } from "@homarr/integrations/types";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const firewallCpuRequestHandler = createCachedIntegrationRequestHandler<
+export const firewallCpuRequestHandler = createIntegrationRequestHandler<
   FirewallCpuSummary,
   IntegrationKindByCategory<"firewall">,
   Record<string, never>
@@ -20,11 +18,9 @@ export const firewallCpuRequestHandler = createCachedIntegrationRequestHandler<
     const integrationInstance = await createIntegrationAsync(integration);
     return integrationInstance.getFirewallCpuAsync();
   },
-  cacheDuration: dayjs.duration(5, "seconds"),
-  queryKey: "firewallCpuSummary",
 });
 
-export const firewallMemoryRequestHandler = createCachedIntegrationRequestHandler<
+export const firewallMemoryRequestHandler = createIntegrationRequestHandler<
   FirewallMemorySummary,
   IntegrationKindByCategory<"firewall">,
   Record<string, never>
@@ -33,11 +29,9 @@ export const firewallMemoryRequestHandler = createCachedIntegrationRequestHandle
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getFirewallMemoryAsync();
   },
-  cacheDuration: dayjs.duration(15, "seconds"),
-  queryKey: "firewallMemorySummary",
 });
 
-export const firewallInterfacesRequestHandler = createCachedIntegrationRequestHandler<
+export const firewallInterfacesRequestHandler = createIntegrationRequestHandler<
   FirewallInterfacesSummary[],
   IntegrationKindByCategory<"firewall">,
   Record<string, never>
@@ -46,11 +40,9 @@ export const firewallInterfacesRequestHandler = createCachedIntegrationRequestHa
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getFirewallInterfacesAsync();
   },
-  cacheDuration: dayjs.duration(30, "seconds"),
-  queryKey: "firewallInterfacesSummary",
 });
 
-export const firewallVersionRequestHandler = createCachedIntegrationRequestHandler<
+export const firewallVersionRequestHandler = createIntegrationRequestHandler<
   FirewallVersionSummary,
   IntegrationKindByCategory<"firewall">,
   Record<string, never>
@@ -59,6 +51,4 @@ export const firewallVersionRequestHandler = createCachedIntegrationRequestHandl
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getFirewallVersionAsync();
   },
-  cacheDuration: dayjs.duration(1, "hour"),
-  queryKey: "firewallVersionSummary",
 });

packages/request-handler/src/health-monitoring.ts

@@ -1,12 +1,10 @@
-import dayjs from "dayjs";
-
 import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
 import type { ProxmoxClusterInfo, SystemHealthMonitoring } from "@homarr/integrations/types";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const systemInfoRequestHandler = createCachedIntegrationRequestHandler<
+export const systemInfoRequestHandler = createIntegrationRequestHandler<
   SystemHealthMonitoring,
   Exclude<IntegrationKindByCategory<"healthMonitoring">, "proxmox" | "coolify" | "beszel">,
   Record<string, never>
@@ -15,11 +13,9 @@ export const systemInfoRequestHandler = createCachedIntegrationRequestHandler<
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getSystemInfoAsync();
   },
-  cacheDuration: dayjs.duration(5, "seconds"),
-  queryKey: "systemInfo",
 });
 
-export const clusterInfoRequestHandler = createCachedIntegrationRequestHandler<
+export const clusterInfoRequestHandler = createIntegrationRequestHandler<
   ProxmoxClusterInfo,
   "proxmox" | "mock",
   Record<string, never>
@@ -28,6 +24,4 @@ export const clusterInfoRequestHandler = createCachedIntegrationRequestHandler<
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getClusterInfoAsync();
   },
-  cacheDuration: dayjs.duration(5, "seconds"),
-  queryKey: "clusterInfo",
 });

packages/request-handler/src/immich.ts

@@ -1,12 +1,10 @@
-import dayjs from "dayjs";
-
 import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
 import type { ImmichAlbum, ImmichServerStats } from "@homarr/integrations";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const immichStatsRequestHandler = createCachedIntegrationRequestHandler<
+export const immichStatsRequestHandler = createIntegrationRequestHandler<
   ImmichServerStats,
   IntegrationKindByCategory<"photoService">,
   Record<string, never>
@@ -15,11 +13,9 @@ export const immichStatsRequestHandler = createCachedIntegrationRequestHandler<
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getServerStatsAsync();
   },
-  cacheDuration: dayjs.duration(15, "minute"),
-  queryKey: "immich-server-stats",
 });
 
-export const immichAlbumsRequestHandler = createCachedIntegrationRequestHandler<
+export const immichAlbumsRequestHandler = createIntegrationRequestHandler<
   {
     id: string;
     albumName: string;
@@ -32,11 +28,9 @@ export const immichAlbumsRequestHandler = createCachedIntegrationRequestHandler<
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getAlbumsAsync();
   },
-  cacheDuration: dayjs.duration(15, "minute"),
-  queryKey: "immich-albums",
 });
 
-export const immichAlbumRequestHandler = createCachedIntegrationRequestHandler<
+export const immichAlbumRequestHandler = createIntegrationRequestHandler<
   ImmichAlbum,
   IntegrationKindByCategory<"photoService">,
   { albumId: string }
@@ -45,6 +39,4 @@ export const immichAlbumRequestHandler = createCachedIntegrationRequestHandler<
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getAlbumAsync(input.albumId);
   },
-  cacheDuration: dayjs.duration(15, "minute"),
-  queryKey: "immich-album",
 });

packages/request-handler/src/indexer-manager.ts

@@ -1,12 +1,10 @@
-import dayjs from "dayjs";
-
 import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { createIntegrationAsync } from "@homarr/integrations";
 import type { Indexer } from "@homarr/integrations/types";
 
-import { createCachedIntegrationRequestHandler } from "./lib/cached-integration-request-handler";
+import { createIntegrationRequestHandler } from "./lib/integration-request-handler";
 
-export const indexerManagerRequestHandler = createCachedIntegrationRequestHandler<
+export const indexerManagerRequestHandler = createIntegrationRequestHandler<
   Indexer[],
   IntegrationKindByCategory<"indexerManager">,
   Record<string, never>
@@ -15,6 +13,4 @@ export const indexerManagerRequestHandler = createCachedIntegrationRequestHandle
     const integrationInstance = await createIntegrationAsync(integration);
     return await integrationInstance.getIndexersAsync();
   },
-  cacheDuration: dayjs.duration(5, "minutes"),
-  queryKey: "indexerManager",
 });

packages/request-handler/src/lib/cached-integration-request-handler.ts

@@ -1,49 +0,0 @@
-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 }),
-  };
-};