feat: refine mobile dashboard experience

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

@@ -1,47 +1,17 @@
 import { z } from "zod/v4";
 
-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 { PUBLIC_INTEGRATION_ERROR, settleIntegrationQueries } from "../../settle-integrations";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, protectedProcedure, publicProcedure } from "../../trpc";
 
 const createDownloadClientIntegrationMiddleware = (action: IntegrationAction) =>
   createManyIntegrationMiddleware(action, ...getIntegrationKindsByCategory("downloadClient"));
 
-interface DownloadClientQueryResultBase {
-  integrationId: string;
-  integrationName: string;
-}
-
-type DownloadClientQueryResult = DownloadClientQueryResultBase &
-  (
-    | {
-        integration: {
-          id: string;
-          name: string;
-          kind: IntegrationKindByCategory<"downloadClient">;
-          updatedAt: Date;
-        };
-        data: DownloadClientJobsAndStatus;
-        error?: never;
-      }
-    | {
-        integration: {
-          id: string;
-          name: string;
-          kind: IntegrationKindByCategory<"downloadClient">;
-        };
-        data: null;
-        error: string;
-      }
-  );
-
 export const downloadsRouter = createTRPCRouter({
   getJobsAndStatuses: publicProcedure
     .meta({
@@ -54,29 +24,14 @@ export const downloadsRouter = createTRPCRouter({
     .concat(createDownloadClientIntegrationMiddleware("query"))
     .input(z.object({ limitPerIntegration: z.number().default(50) }))
     .query(async ({ ctx, input }) => {
-      return await settleIntegrationQueries<(typeof ctx.integrations)[number], DownloadClientQueryResult>(
-        ctx.integrations,
-        async (integration) => {
-          const innerHandler = downloadClientRequestHandler.handler(integration, { limit: input.limitPerIntegration });
-          const { data, timestamp } = await innerHandler.getDataAsync();
-          return {
-            integrationId: integration.id,
-            integrationName: integration.name,
-            integration: { id: integration.id, name: integration.name, kind: integration.kind, updatedAt: timestamp },
-            data,
-          };
-        },
-        {
-          fallback: (integration) => ({
-            integrationId: integration.id,
-            integrationName: integration.name,
-            integration: { id: integration.id, name: integration.name, kind: integration.kind },
-            data: null,
-            error: PUBLIC_INTEGRATION_ERROR,
-          }),
-          throwOnAllFailures: true,
-        },
-      );
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
+        const innerHandler = downloadClientRequestHandler.handler(integration, { limit: input.limitPerIntegration });
+        const { data, timestamp } = await innerHandler.getDataAsync();
+        return {
+          integration: { id: integration.id, name: integration.name, kind: integration.kind, updatedAt: timestamp },
+          data,
+        };
+      });
     }),
   pause: protectedProcedure
     .meta({

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

@@ -1,10 +1,9 @@
 import { createIntegrationAsync } from "@homarr/integrations";
-import type { SystemHealthMonitoring } from "@homarr/integrations";
 import { SynologyIntegration } from "@homarr/integrations";
 import { clusterInfoRequestHandler, systemInfoRequestHandler } from "@homarr/request-handler/health-monitoring";
 
 import { createManyIntegrationMiddleware, createOneIntegrationMiddleware } from "../../middlewares/integration";
-import { PUBLIC_INTEGRATION_ERROR, settleIntegrationQueries } from "../../settle-integrations";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 const healthMonitoringIntegrationKinds = [
@@ -17,14 +16,6 @@ const healthMonitoringIntegrationKinds = [
   "mock",
 ] as const;
 
-interface SystemHealthQueryResult {
-  integrationId: string;
-  integrationName: string;
-  healthInfo: SystemHealthMonitoring | null;
-  updatedAt?: Date;
-  error?: string;
-}
-
 export const healthMonitoringRouter = createTRPCRouter({
   getSystemHealthStatus: publicProcedure
     .meta({
@@ -36,27 +27,15 @@ export const healthMonitoringRouter = createTRPCRouter({
     })
     .concat(createManyIntegrationMiddleware("query", ...healthMonitoringIntegrationKinds))
     .query(async ({ ctx }) => {
-      return await settleIntegrationQueries<(typeof ctx.integrations)[number], SystemHealthQueryResult>(
-        ctx.integrations,
-        async (integration) => {
-          const { data, timestamp } = await systemInfoRequestHandler.handler(integration, {}).getDataAsync();
-          return {
-            integrationId: integration.id,
-            integrationName: integration.name,
-            healthInfo: data,
-            updatedAt: timestamp,
-          };
-        },
-        {
-          fallback: (integration) => ({
-            integrationId: integration.id,
-            integrationName: integration.name,
-            healthInfo: null,
-            error: PUBLIC_INTEGRATION_ERROR,
-          }),
-          throwOnAllFailures: true,
-        },
-      );
+      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,
+        };
+      });
     }),
   listStorageVolumes: publicProcedure
     .meta({

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

@@ -2,21 +2,32 @@ import { getIntegrationKindsByCategory } from "@homarr/definitions";
 import { mediaReleaseRequestHandler } from "@homarr/request-handler/media-release";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
-import { getMediaReleaseResponse } from "./media-release-result";
 
 export const mediaReleaseRouter = createTRPCRouter({
   getMediaReleases: publicProcedure
     .concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("mediaRelease")))
     .query(async ({ ctx }) => {
-      return await getMediaReleaseResponse(ctx.integrations, async (integration) => {
+      const results = await settleIntegrationQueries(ctx.integrations, async (integration) => {
         const innerHandler = mediaReleaseRequestHandler.handler(integration, {});
         const { data, timestamp } = await innerHandler.getDataAsync();
 
         return {
+          integration: {
+            id: integration.id,
+            name: integration.name,
+            kind: integration.kind,
+            updatedAt: timestamp,
+          },
           releases: data,
-          updatedAt: timestamp,
         };
       });
+      return results.flatMap((result) =>
+        result.releases.map((release) => ({
+          ...release,
+          integration: result.integration,
+        })),
+      );
     }),
 });

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

@@ -1,39 +1,24 @@
 import { uptimeKumaRequestHandler } from "@homarr/request-handler/uptime-kuma";
 
 import { createManyIntegrationMiddleware } from "../../middlewares/integration";
-import { settleIntegrationQueries, toPublicIntegrationError } from "../../settle-integrations";
+import { settleIntegrationQueries } from "../../settle-integrations";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const uptimeKumaRouter = createTRPCRouter({
   getDashboard: publicProcedure
     .concat(createManyIntegrationMiddleware("query", "uptimeKuma"))
     .query(async ({ ctx }) => {
-      return await settleIntegrationQueries(
-        ctx.integrations,
-        async (integration) => {
-          const innerHandler = uptimeKumaRequestHandler.handler(integration, {});
-          const { data, timestamp } = await innerHandler.getDataAsync();
+      return await settleIntegrationQueries(ctx.integrations, async (integration) => {
+        const innerHandler = uptimeKumaRequestHandler.handler(integration, {});
+        const { data, timestamp } = await innerHandler.getDataAsync();
 
-          return {
-            integrationId: integration.id,
-            integrationName: integration.name,
-            integrationUrl: integration.url,
-            dashboard: data as typeof data | null,
-            updatedAt: timestamp,
-            error: undefined as string | undefined,
-          };
-        },
-        {
-          fallback: (integration, error) => ({
-            integrationId: integration.id,
-            integrationName: integration.name,
-            integrationUrl: integration.url,
-            dashboard: null,
-            updatedAt: new Date(0),
-            error: toPublicIntegrationError(error),
-          }),
-          throwOnAllFailures: true,
-        },
-      );
+        return {
+          integrationId: integration.id,
+          integrationName: integration.name,
+          integrationUrl: integration.url,
+          dashboard: data,
+          updatedAt: timestamp,
+        };
+      });
     }),
 });