refactor: add request handlers for centralized cached requests (#1504)

* feat: add object base64 hash method

* chore: add script to add package

* feat: add request-handler package

* wip: add request handlers for all jobs and widget api procedures

* wip: remove errors shown in logs, add missing decryption for secrets in cached-request-job-handler

* wip: highly improve request handler, add request handlers for calendar, media-server, indexer-manager and more, add support for multiple inputs from job handler creator

* refactor: move media-server requests to request-handler, add invalidation logic for dns-hole and media requests

* refactor: remove unused integration item middleware

* feat: add invalidation to switch entity action of smart-home

* fix: lint issues

* chore: use integration-kind-by-category instead of union for request-handlers

* fix: build not working for tasks and websocket

* refactor: add more logs

* refactor: readd timestamp logic for diconnect status

* fix: lint and typecheck issue

* chore: address pull request feedback

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

@@ -2,31 +2,33 @@ import { observable } from "@trpc/server/observable";
 
 import type { Modify } from "@homarr/common/types";
 import type { Integration } from "@homarr/db/schema/sqlite";
-import type { IntegrationKindByCategory, WidgetKind } from "@homarr/definitions";
+import type { IntegrationKindByCategory } from "@homarr/definitions";
 import { getIntegrationKindsByCategory } from "@homarr/definitions";
 import { integrationCreator } from "@homarr/integrations";
 import type { DnsHoleSummary } from "@homarr/integrations/types";
 import { controlsInputSchema } from "@homarr/integrations/types";
-import { createItemAndIntegrationChannel } from "@homarr/redis";
-import { z } from "@homarr/validation";
+import { dnsHoleRequestHandler } from "@homarr/request-handler/dns-hole";
 
 import { createManyIntegrationMiddleware, createOneIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 export const dnsHoleRouter = createTRPCRouter({
   summary: publicProcedure
-    .input(z.object({ widgetKind: z.enum(["dnsHoleSummary", "dnsHoleControls"]) }))
     .unstable_concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("dnsHole")))
-    .query(async ({ input: { widgetKind }, ctx }) => {
+    .query(async ({ ctx }) => {
       const results = await Promise.all(
-        ctx.integrations.map(async ({ decryptedSecrets: _, ...integration }) => {
-          const channel = createItemAndIntegrationChannel<DnsHoleSummary>(widgetKind, integration.id);
-          const { data: summary, timestamp } = (await channel.getAsync()) ?? { data: null, timestamp: new Date(0) };
+        ctx.integrations.map(async (integration) => {
+          const innerHandler = dnsHoleRequestHandler.handler(integration, {});
+          const { data, timestamp } = await innerHandler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
 
           return {
-            integration,
-            timestamp,
-            summary,
+            integration: {
+              id: integration.id,
+              name: integration.name,
+              kind: integration.kind,
+              updatedAt: timestamp,
+            },
+            summary: data,
           };
         }),
       );
@@ -34,22 +36,19 @@ export const dnsHoleRouter = createTRPCRouter({
     }),
 
   subscribeToSummary: publicProcedure
-    .input(z.object({ widgetKind: z.enum(["dnsHoleSummary", "dnsHoleControls"]) }))
     .unstable_concat(createManyIntegrationMiddleware("query", ...getIntegrationKindsByCategory("dnsHole")))
-    .subscription(({ input: { widgetKind }, ctx }) => {
+    .subscription(({ ctx }) => {
       return observable<{
         integration: Modify<Integration, { kind: IntegrationKindByCategory<"dnsHole"> }>;
-        timestamp: Date;
         summary: DnsHoleSummary;
       }>((emit) => {
         const unsubscribes: (() => void)[] = [];
         for (const integrationWithSecrets of ctx.integrations) {
           const { decryptedSecrets: _, ...integration } = integrationWithSecrets;
-          const channel = createItemAndIntegrationChannel<DnsHoleSummary>(widgetKind as WidgetKind, integration.id);
-          const unsubscribe = channel.subscribe((summary) => {
+          const innerHandler = dnsHoleRequestHandler.handler(integrationWithSecrets, {});
+          const unsubscribe = innerHandler.subscribe((summary) => {
             emit.next({
               integration,
-              timestamp: new Date(),
               summary,
             });
           });
@@ -68,6 +67,12 @@ export const dnsHoleRouter = createTRPCRouter({
     .mutation(async ({ ctx: { integration } }) => {
       const client = integrationCreator(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: publicProcedure
@@ -76,5 +81,11 @@ export const dnsHoleRouter = createTRPCRouter({
     .mutation(async ({ ctx: { integration }, input }) => {
       const client = integrationCreator(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);
+      });
     }),
 });