refactor widget-only integrations

packages/api/src/router/test/integration/integration-test-connection.spec.ts

@@ -271,77 +271,4 @@ describe("testConnectionAsync should run test connection of integration", () =>
     });
   });
 
-  test("with input of existing github app", async () => {
-    // Arrange
-    const factorySpy = vi.spyOn(homarrIntegrations, "createIntegrationAsync");
-    const optionsSpy = vi.spyOn(homarrDefinitions, "getAllSecretKindOptions");
-    factorySpy.mockReturnValue(
-      Promise.resolve({
-        testConnectionAsync: async () => await Promise.resolve({ success: true }),
-      } as homarrIntegrations.PiHoleIntegrationV6),
-    );
-    optionsSpy.mockReturnValue([[], ["githubAppId", "githubInstallationId", "privateKey"]]);
-
-    const integration = {
-      id: "new",
-      name: "GitHub",
-      url: "https://api.github.com",
-      kind: "github" as const,
-      secrets: [
-        {
-          kind: "githubAppId" as const,
-          value: "345",
-        },
-        {
-          kind: "githubInstallationId" as const,
-          value: "456",
-        },
-        {
-          kind: "privateKey" as const,
-          value: null,
-        },
-      ],
-    };
-
-    const dbSecrets = [
-      {
-        kind: "githubAppId" as const,
-        value: "123.encrypted" as const,
-      },
-      {
-        kind: "githubInstallationId" as const,
-        value: "234.encrypted" as const,
-      },
-      {
-        kind: "privateKey" as const,
-        value: "privateKey.encrypted" as const,
-      },
-    ];
-
-    // Act
-    await testConnectionAsync(integration, dbSecrets);
-
-    // Assert
-    expect(factorySpy).toHaveBeenCalledWith({
-      id: "new",
-      name: "GitHub",
-      url: "https://api.github.com",
-      kind: "github" as const,
-      decryptedSecrets: [
-        expect.objectContaining({
-          kind: "githubAppId",
-          value: "345",
-        }),
-        expect.objectContaining({
-          kind: "githubInstallationId",
-          value: "456",
-        }),
-        expect.objectContaining({
-          kind: "privateKey",
-          value: "privateKey",
-        }),
-      ],
-      externalUrl: null,
-    });
-  });
 });

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

@@ -1,39 +1,37 @@
 import { observable } from "@trpc/server/observable";
+import { z } from "zod/v4";
 
-import type { ArchiveTeamWarriorStatus } from "@homarr/integrations";
+import type { ArchiveTeamWarriorStatus } from "@homarr/request-handler/archive-team-warrior";
 import { archiveTeamWarriorRequestHandler } from "@homarr/request-handler/archive-team-warrior";
 
-import { createOneIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
+const inputSchema = z.object({ url: z.string().url() });
+
 export const archiveTeamWarriorRouter = createTRPCRouter({
-  getStatus: publicProcedure
-    .concat(createOneIntegrationMiddleware("query", "archiveTeamWarrior"))
-    .query(async ({ ctx }) => {
-      const handler = archiveTeamWarriorRequestHandler.handler(ctx.integration, {});
-      const { data, timestamp } = await handler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
+  getStatus: publicProcedure.input(inputSchema).query(async ({ input }) => {
+    const handler = archiveTeamWarriorRequestHandler.handler({ url: input.url });
+    const { data, timestamp } = await handler.getCachedOrUpdatedDataAsync({ forceUpdate: false });
 
-      return {
-        status: data,
-        updatedAt: timestamp,
-      };
-    }),
+    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(),
-          });
+  subscribeStatus: publicProcedure.input(inputSchema).subscription(({ input }) => {
+    return observable<{ status: ArchiveTeamWarriorStatus; updatedAt: Date }>((emit) => {
+      const handler = archiveTeamWarriorRequestHandler.handler({ url: input.url });
+      const unsubscribe = handler.subscribe((status) => {
+        emit.next({
+          status,
+          updatedAt: new Date(),
         });
-
-        return () => {
-          unsubscribe();
-        };
       });
-    }),
+
+      return () => {
+        unsubscribe();
+      };
+    });
+  }),
 });

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

@@ -1,10 +1,9 @@
 import { escapeForRegEx } from "@tiptap/react";
 import { z } from "zod/v4";
 
-import { getIntegrationKindsByCategory } from "@homarr/definitions";
+import { releaseProviderKinds } from "@homarr/definitions";
 import { releasesRequestHandler } from "@homarr/request-handler/releases";
 
-import { createOneIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
 const formatVersionFilterRegex = (versionFilter: z.infer<typeof releaseVersionFilterSchema> | undefined) => {
@@ -25,26 +24,29 @@ const releaseVersionFilterSchema = z.object({
 
 export const releasesRouter = createTRPCRouter({
   getLatest: publicProcedure
-    .concat(createOneIntegrationMiddleware("query", ...getIntegrationKindsByCategory("releasesProvider")))
     .input(
       z.object({
         repositories: z.array(
           z.object({
             id: z.string(),
+            provider: z.enum(releaseProviderKinds),
             identifier: z.string(),
             versionFilter: releaseVersionFilterSchema.optional(),
+            providerUrl: z.string().url().optional(),
           }),
         ),
       }),
     )
-    .query(async ({ ctx, input }) => {
+    .query(async ({ input }) => {
       return await Promise.all(
         input.repositories.map(async (repository) => {
           const response = await releasesRequestHandler
-            .handler(ctx.integration, {
+            .handler({
               id: repository.id,
+              provider: repository.provider,
               identifier: repository.identifier,
               versionRegex: formatVersionFilterRegex(repository.versionFilter),
+              providerUrl: repository.providerUrl,
             })
             .getCachedOrUpdatedDataAsync({
               forceUpdate: false,
@@ -52,7 +54,7 @@ export const releasesRouter = createTRPCRouter({
 
           return {
             id: repository.id,
-            integration: { name: ctx.integration.name, kind: ctx.integration.kind },
+            provider: repository.provider,
             timestamp: response.timestamp,
             ...response.data,
           };

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

@@ -1,21 +1,26 @@
 import z from "zod";
 
-import { getIntegrationKindsByCategory } from "@homarr/definitions";
-import { timetableOptionsSchema } from "@homarr/integrations/types";
 import {
   timetableGetTimetableRequestHandler,
   timetableSearchStationsRequestHandler,
 } from "@homarr/request-handler/timetable";
 
-import { createOneIntegrationMiddleware } from "../../middlewares/integration";
 import { createTRPCRouter, publicProcedure } from "../../trpc";
 
+const baseUrlSchema = z.string().url();
+
 export const timetableRouter = createTRPCRouter({
   getTimetable: publicProcedure
-    .concat(createOneIntegrationMiddleware("query", ...getIntegrationKindsByCategory("timetable")))
-    .input(timetableOptionsSchema)
-    .query(async ({ input, ctx }) => {
-      const innerHandler = timetableGetTimetableRequestHandler.handler(ctx.integration, {
+    .input(
+      z.object({
+        baseUrl: baseUrlSchema,
+        stationId: z.string(),
+        limit: z.number(),
+      }),
+    )
+    .query(async ({ input }) => {
+      const innerHandler = timetableGetTimetableRequestHandler.handler({
+        baseUrl: input.baseUrl,
         stationId: input.stationId,
         limit: input.limit,
       });
@@ -25,14 +30,15 @@ export const timetableRouter = createTRPCRouter({
       return data;
     }),
   searchStations: publicProcedure
-    .concat(createOneIntegrationMiddleware("query", ...getIntegrationKindsByCategory("timetable")))
     .input(
       z.object({
+        baseUrl: baseUrlSchema,
         query: z.string(),
       }),
     )
-    .query(async ({ input, ctx }) => {
-      const innerHandler = timetableSearchStationsRequestHandler.handler(ctx.integration, {
+    .query(async ({ input }) => {
+      const innerHandler = timetableSearchStationsRequestHandler.handler({
+        baseUrl: input.baseUrl,
         query: input.query,
       });