feat: configure custom widget sources

2026-07-22 18:12:09 +02:00
1 parent 47cd7dda1f
commit e94b4d4bc9
@@ -0,0 +1,104 @@
+import { createId } from "@homarr/common";
+import { createRedisClient } from "@homarr/core/infrastructure/redis";
+import type { RedisClient } from "@homarr/core/infrastructure/redis";
+import type { CustomWidgetSecretKind } from "@homarr/custom-widgets/core";
+import type { CustomWidgetSource } from "@homarr/custom-widgets/core";
+
+const CONFIGURATION_REQUEST_TTL_MS = 10 * 60_000;
+const CONFIGURATION_REQUEST_PREFIX = "custom-widget:configuration-request:";
+const CONFIGURATION_REQUEST_LOCK_PREFIX = "custom-widget:configuration-request-lock:";
+
+export interface CustomWidgetConfigurationRequest {
+  id: string;
+  userId: string;
+  target: { type: "definition"; id: string } | { type: "preview"; id: string };
+  widgetName: string;
+  sourceId: string;
+  sourceName: string;
+  source: CustomWidgetSource;
+  kinds: CustomWidgetSecretKind[];
+  expiresAt: number;
+  status: "pending" | "completed";
+}
+
+const localRequests = new Map<string, CustomWidgetConfigurationRequest>();
+const localLocks = new Set<string>();
+let redis: RedisClient | undefined;
+
+function getRedis() {
+  if (process.env.CI !== undefined || process.env.NODE_ENV === "test") return undefined;
+  redis ??= createRedisClient();
+  return redis;
+}
+
+async function save(request: CustomWidgetConfigurationRequest) {
+  const ttl = Math.max(1, request.expiresAt - Date.now());
+  const client = getRedis();
+  if (client) await client.set(`${CONFIGURATION_REQUEST_PREFIX}${request.id}`, JSON.stringify(request), "PX", ttl);
+  else localRequests.set(request.id, request);
+}
+
+export async function createCustomWidgetConfigurationRequest(
+  input: Omit<CustomWidgetConfigurationRequest, "id" | "expiresAt" | "status">,
+) {
+  const request: CustomWidgetConfigurationRequest = {
+    ...input,
+    id: createId(),
+    expiresAt: Date.now() + CONFIGURATION_REQUEST_TTL_MS,
+    status: "pending",
+  };
+  await save(request);
+  return request;
+}
+
+export async function getCustomWidgetConfigurationRequest(id: string) {
+  const client = getRedis();
+  const candidate = client ? await client.get(`${CONFIGURATION_REQUEST_PREFIX}${id}`) : localRequests.get(id);
+  if (!candidate) return null;
+  try {
+    const request = (typeof candidate === "string" ? JSON.parse(candidate) : candidate) as CustomWidgetConfigurationRequest;
+    if (request.expiresAt <= Date.now()) {
+      if (client) await client.del(`${CONFIGURATION_REQUEST_PREFIX}${id}`);
+      else localRequests.delete(id);
+      return null;
+    }
+    return request;
+  } catch {
+    return null;
+  }
+}
+
+export async function getCustomWidgetConfigurationRequestForUser(id: string, userId: string) {
+  const request = await getCustomWidgetConfigurationRequest(id);
+  return request?.userId === userId ? request : null;
+}
+
+export async function completeCustomWidgetConfigurationRequest(id: string) {
+  const request = await getCustomWidgetConfigurationRequest(id);
+  if (!request || request.status !== "pending") return null;
+  const completed = { ...request, status: "completed" as const };
+  await save(completed);
+  await releaseCustomWidgetConfigurationRequest(id);
+  return completed;
+}
+
+export async function claimCustomWidgetConfigurationRequest(id: string) {
+  const request = await getCustomWidgetConfigurationRequest(id);
+  if (!request || request.status !== "pending") return null;
+  const client = getRedis();
+  if (client) {
+    const claimed = await client.set(`${CONFIGURATION_REQUEST_LOCK_PREFIX}${id}`, "1", "PX", 60_000, "NX");
+    return claimed === "OK" ? request : null;
+  }
+  if (localLocks.has(id)) return null;
+  localLocks.add(id);
+  return request;
+}
+
+export async function releaseCustomWidgetConfigurationRequest(id: string) {
+  const client = getRedis();
+  if (client) await client.del(`${CONFIGURATION_REQUEST_LOCK_PREFIX}${id}`);
+  else localLocks.delete(id);
+}
+
+export { setPreviewSessionSecrets } from "./preview-sessions";
@@ -28,6 +28,7 @@ import { templateProcedures } from "./template-procedures";
 import { transferProcedures } from "./transfer-procedures";
 import { assertSecretSources, requiredSecretKinds } from "./secret-policy";
 import { secretProcedures } from "./secret-procedures";
+import { workshopProcedures } from "./workshop-procedures";

 const manageProcedure = permissionRequiredProcedure.requiresPermission("custom-widget-manage");
 const logger = createLogger({ module: "custom-widget" });
@@ -167,6 +168,7 @@ export const customWidgetRouter = createTRPCRouter({
    }),

  ...secretProcedures,
+  ...workshopProcedures,

  toggleEnabled: manageProcedure
    .input(z.object({ id: z.string(), enabled: z.boolean() }))
@@ -80,3 +80,10 @@ export const getPreviewSessionSecrets = (session: CustomWidgetPreviewSession, so
  getService().getSecrets(session, sourceId);
 export const setPreviewSessionSecrets = (id: string, userId: string, secrets: CreatePreviewSessionInput["secrets"]) =>
  call(() => getService().setSecrets(id, userId, secrets));
+export const configurePreviewSessionSource = (
+  id: string,
+  userId: string,
+  sourceId: string,
+  source: CreatePreviewSessionInput["sources"][string],
+  secrets: CreatePreviewSessionInput["secrets"],
+) => call(() => getService().configureSource(id, userId, sourceId, source, secrets));
@@ -2,15 +2,23 @@ import { TRPCError } from "@trpc/server";
 import { z } from "zod/v4";

 import { encryptSecret } from "@homarr/common/server";
-import { and, eq } from "@homarr/db";
+import { and, eq, handleTransactionsAsync } from "@homarr/db";
 import { customWidgetDefinitions, customWidgetSecrets } from "@homarr/db/schema";
-import { customWidgetSecretInputSchema } from "@homarr/custom-widgets/core";
+import {
+  customWidgetSecretInputSchema,
+  customWidgetSecretsInputSchema,
+  customWidgetSourceSchema,
+} from "@homarr/custom-widgets/core";
+import type { CustomWidgetSource } from "@homarr/custom-widgets/core";

 import { permissionRequiredProcedure } from "../../trpc";
-import { createCustomWidgetSecretRequest, getCustomWidgetSecretRequestForUser } from "./secret-requests";
+import {
+  createCustomWidgetConfigurationRequest,
+  getCustomWidgetConfigurationRequestForUser,
+} from "./configuration-requests";
 import { assertSecretSources, requiredSecretKinds } from "./secret-policy";
 import { getPreviewSession } from "./preview-sessions";
-import { parseStoredCustomWidgetDefinition } from "./stored-definition";
+import { parseStoredCustomWidgetDefinition, serializeCustomWidgetDefinition } from "./stored-definition";

 const manageProcedure = permissionRequiredProcedure.requiresPermission("custom-widget-manage");
 const secretWriteProcedure = permissionRequiredProcedure.requiresPermission("custom-widget-secret-write");
@@ -69,18 +77,108 @@ export const secretProcedures = {
      return { sourceId: input.secret.sourceId, kind: input.secret.kind, isSet: true };
    }),

-  secretRequestUser: manageProcedure
-    .meta({ mcp: { enabled: true, description: "Create or check a short-lived user credential-entry request." } })
+  sourceConfigure: manageProcedure
+    .meta({ mcp: { enabled: true, description: "Configure one custom widget API source and its credentials." } })
+    .input(
+      z.object({
+        definitionId: z.string(),
+        sourceId: z.string(),
+        baseUrl: z.string(),
+        networkScope: z.enum(["public", "private", "loopback"]).optional(),
+        secrets: customWidgetSecretsInputSchema.default([]),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      if (input.secrets.length > 0 && !ctx.session.user.permissions.includes("custom-widget-secret-write")) {
+        throw new TRPCError({ code: "FORBIDDEN", message: "Writing source credentials requires dedicated permission" });
+      }
+      const stored = await ctx.db.query.customWidgetDefinitions.findFirst({
+        where: eq(customWidgetDefinitions.id, input.definitionId),
+      });
+      if (!stored) throw new TRPCError({ code: "NOT_FOUND" });
+      const definition = parseStoredCustomWidgetDefinition(stored);
+      const current = definition.sources[input.sourceId];
+      if (!current) throw new TRPCError({ code: "NOT_FOUND", message: "Widget source not found" });
+      const source = customWidgetSourceSchema.parse({
+        ...current,
+        baseUrl: input.baseUrl,
+        networkScope: input.networkScope ?? current.networkScope,
+      });
+      assertSecretSources({ [input.sourceId]: source }, input.secrets);
+      const updated = { ...definition, sources: { ...definition.sources, [input.sourceId]: source } };
+      const definitionChanges = { ...serializeCustomWidgetDefinition(updated), updatedAt: new Date() };
+      const secretRows = input.secrets.map((secret) => ({
+        definitionId: input.definitionId,
+        sourceId: input.sourceId,
+        kind: secret.kind,
+        encryptedValue: encryptSecret(secret.value),
+        updatedAt: new Date(),
+      }));
+      await handleTransactionsAsync(ctx.db, {
+        async handleAsync(db, schema) {
+          await db.transaction(async (transaction) => {
+            await transaction
+              .update(schema.customWidgetDefinitions)
+              .set(definitionChanges)
+              .where(eq(schema.customWidgetDefinitions.id, input.definitionId));
+            for (const secret of secretRows) {
+              await transaction
+                .delete(schema.customWidgetSecrets)
+                .where(
+                  and(
+                    eq(schema.customWidgetSecrets.definitionId, input.definitionId),
+                    eq(schema.customWidgetSecrets.sourceId, input.sourceId),
+                    eq(schema.customWidgetSecrets.kind, secret.kind),
+                  ),
+                );
+              await transaction.insert(schema.customWidgetSecrets).values(secret);
+            }
+          });
+        },
+        handleSync(db) {
+          db.transaction((transaction) => {
+            transaction
+              .update(customWidgetDefinitions)
+              .set(definitionChanges)
+              .where(eq(customWidgetDefinitions.id, input.definitionId))
+              .run();
+            for (const secret of secretRows) {
+              transaction
+                .delete(customWidgetSecrets)
+                .where(
+                  and(
+                    eq(customWidgetSecrets.definitionId, input.definitionId),
+                    eq(customWidgetSecrets.sourceId, input.sourceId),
+                    eq(customWidgetSecrets.kind, secret.kind),
+                  ),
+                )
+                .run();
+              transaction.insert(customWidgetSecrets).values(secret).run();
+            }
+          });
+        },
+      });
+      return {
+        definitionId: input.definitionId,
+        sourceId: input.sourceId,
+        baseUrl: source.baseUrl,
+        networkScope: source.networkScope,
+        configuredSecrets: input.secrets.map(({ kind }) => kind),
+      };
+    }),
+
+  configurationRequestUser: manageProcedure
+    .meta({ mcp: { enabled: true, description: "Create or check a short-lived user source-configuration request." } })
    .input(secretRequestInputSchema)
    .mutation(async ({ ctx, input }) => {
      if (input.requestId) {
-        const request = await getCustomWidgetSecretRequestForUser(input.requestId, ctx.session.user.id);
+        const request = await getCustomWidgetConfigurationRequestForUser(input.requestId, ctx.session.user.id);
        if (!request) throw new TRPCError({ code: "NOT_FOUND" });
        return { requestId: request.id, status: request.status, expiresAt: request.expiresAt };
      }

      let widgetName: string;
-      let source: { id: string; name: string; auth: string | { type: string } } | undefined;
+      let source: { id: string; name: string; auth: string | { type: string }; value: CustomWidgetSource } | undefined;
      let target: { type: "definition"; id: string } | { type: "preview"; id: string };
      if (input.definitionId) {
        const stored = await ctx.db.query.customWidgetDefinitions.findFirst({
@@ -91,36 +189,44 @@ export const secretProcedures = {
        widgetName = definition.name;
        const candidate = definition.sources[input.sourceId ?? ""];
        source = candidate
-          ? { id: input.sourceId ?? "", name: candidate.name ?? input.sourceId ?? "", auth: candidate.auth }
+          ? {
+              id: input.sourceId ?? "",
+              name: candidate.name ?? input.sourceId ?? "",
+              auth: candidate.auth,
+              value: candidate,
+            }
          : undefined;
        target = { type: "definition", id: input.definitionId };
      } else {
        const preview = await getPreviewSession(input.previewSessionId ?? "", ctx.session.user.id);
-        widgetName = "Custom widget preview";
+        widgetName = preview.name;
        const candidate = preview.sources[input.sourceId ?? ""];
        source = candidate
-          ? { id: input.sourceId ?? "", name: candidate.name ?? input.sourceId ?? "", auth: candidate.auth }
+          ? {
+              id: input.sourceId ?? "",
+              name: candidate.name ?? input.sourceId ?? "",
+              auth: candidate.auth,
+              value: candidate,
+            }
          : undefined;
        target = { type: "preview", id: preview.id };
      }
      if (!source) throw new TRPCError({ code: "NOT_FOUND", message: "Widget source not found" });
      const kinds = [...requiredSecretKinds(typeof source.auth === "string" ? source.auth : source.auth.type)];
-      if (kinds.length === 0) {
-        throw new TRPCError({ code: "BAD_REQUEST", message: "This source does not require a secret" });
-      }
-      const request = await createCustomWidgetSecretRequest({
+      const request = await createCustomWidgetConfigurationRequest({
        userId: ctx.session.user.id,
        target,
        widgetName,
        sourceId: source.id,
        sourceName: source.name,
+        source: source.value,
        kinds,
      });
      return {
        requestId: request.id,
        status: request.status,
        expiresAt: request.expiresAt,
-        url: new URL(`/custom-widget-secret/${request.id}`, ctx.baseUrl ?? "http://localhost").toString(),
+        url: new URL(`/custom-widget-configuration/${request.id}`, ctx.baseUrl ?? "http://localhost").toString(),
      };
    }),

@@ -1,102 +0,0 @@
-import { createId } from "@homarr/common";
-import { createRedisClient } from "@homarr/core/infrastructure/redis";
-import type { RedisClient } from "@homarr/core/infrastructure/redis";
-import type { CustomWidgetSecretKind } from "@homarr/custom-widgets/core";
-
-const SECRET_REQUEST_TTL_MS = 10 * 60_000;
-const SECRET_REQUEST_PREFIX = "custom-widget:secret-request:";
-const SECRET_REQUEST_LOCK_PREFIX = "custom-widget:secret-request-lock:";
-
-export interface CustomWidgetSecretRequest {
-  id: string;
-  userId: string;
-  target: { type: "definition"; id: string } | { type: "preview"; id: string };
-  widgetName: string;
-  sourceId: string;
-  sourceName: string;
-  kinds: CustomWidgetSecretKind[];
-  expiresAt: number;
-  status: "pending" | "completed";
-}
-
-const localRequests = new Map<string, CustomWidgetSecretRequest>();
-const localLocks = new Set<string>();
-let redis: RedisClient | undefined;
-
-function getRedis() {
-  if (process.env.CI !== undefined || process.env.NODE_ENV === "test") return undefined;
-  redis ??= createRedisClient();
-  return redis;
-}
-
-async function save(request: CustomWidgetSecretRequest) {
-  const ttl = Math.max(1, request.expiresAt - Date.now());
-  const client = getRedis();
-  if (client) await client.set(`${SECRET_REQUEST_PREFIX}${request.id}`, JSON.stringify(request), "PX", ttl);
-  else localRequests.set(request.id, request);
-}
-
-export async function createCustomWidgetSecretRequest(
-  input: Omit<CustomWidgetSecretRequest, "id" | "expiresAt" | "status">,
-) {
-  const request: CustomWidgetSecretRequest = {
-    ...input,
-    id: createId(),
-    expiresAt: Date.now() + SECRET_REQUEST_TTL_MS,
-    status: "pending",
-  };
-  await save(request);
-  return request;
-}
-
-export async function getCustomWidgetSecretRequest(id: string) {
-  const client = getRedis();
-  const candidate = client ? await client.get(`${SECRET_REQUEST_PREFIX}${id}`) : localRequests.get(id);
-  if (!candidate) return null;
-  try {
-    const request = (typeof candidate === "string" ? JSON.parse(candidate) : candidate) as CustomWidgetSecretRequest;
-    if (request.expiresAt <= Date.now()) {
-      if (client) await client.del(`${SECRET_REQUEST_PREFIX}${id}`);
-      else localRequests.delete(id);
-      return null;
-    }
-    return request;
-  } catch {
-    return null;
-  }
-}
-
-export async function getCustomWidgetSecretRequestForUser(id: string, userId: string) {
-  const request = await getCustomWidgetSecretRequest(id);
-  return request?.userId === userId ? request : null;
-}
-
-export async function completeCustomWidgetSecretRequest(id: string) {
-  const request = await getCustomWidgetSecretRequest(id);
-  if (!request || request.status !== "pending") return null;
-  const completed = { ...request, status: "completed" as const };
-  await save(completed);
-  await releaseCustomWidgetSecretRequest(id);
-  return completed;
-}
-
-export async function claimCustomWidgetSecretRequest(id: string) {
-  const request = await getCustomWidgetSecretRequest(id);
-  if (!request || request.status !== "pending") return null;
-  const client = getRedis();
-  if (client) {
-    const claimed = await client.set(`${SECRET_REQUEST_LOCK_PREFIX}${id}`, "1", "PX", 60_000, "NX");
-    return claimed === "OK" ? request : null;
-  }
-  if (localLocks.has(id)) return null;
-  localLocks.add(id);
-  return request;
-}
-
-export async function releaseCustomWidgetSecretRequest(id: string) {
-  const client = getRedis();
-  if (client) await client.del(`${SECRET_REQUEST_LOCK_PREFIX}${id}`);
-  else localLocks.delete(id);
-}
-
-export { setPreviewSessionSecrets } from "./preview-sessions";
@@ -0,0 +1,172 @@
+import { TRPCError } from "@trpc/server";
+import { z } from "zod/v4";
+
+import {
+  applyCustomWidgetSourceSetup,
+  CUSTOM_WIDGET_SCHEMA,
+  customWidgetDefinitionSchema,
+  customWidgetIdentifierSchema,
+  customWidgetSecretsInputSchema,
+  getCustomWidgetSecretRequirements,
+  getCustomWidgetSourceSetups,
+} from "@homarr/custom-widgets/core";
+import { WorkshopBackend } from "@homarr/workshop/backend";
+import { validateWorkshopWidget, WORKSHOP_API_URL } from "@homarr/workshop/schema";
+
+import { permissionRequiredProcedure } from "../../trpc";
+import { insertCustomWidgetDefinition } from "./definition-insert";
+import { assertSecretSources } from "./secret-policy";
+
+const manageProcedure = permissionRequiredProcedure.requiresPermission("custom-widget-manage");
+const workshop = new WorkshopBackend(process.env.WORKSHOP_API_URL ?? WORKSHOP_API_URL);
+
+async function getWorkshopWidget(submissionId: string) {
+  try {
+    const submission = await workshop.get(submissionId);
+    if (submission.type !== "customWidget" || submission.widgetSchema !== CUSTOM_WIDGET_SCHEMA) {
+      throw new TRPCError({
+        code: "BAD_REQUEST",
+        message: "Workshop submission is not a compatible Custom JSX widget",
+      });
+    }
+    const validation = validateWorkshopWidget(submission.content);
+    if (!validation.success) {
+      throw new TRPCError({ code: "BAD_REQUEST", message: validation.error });
+    }
+    return { submission, widget: validation.data };
+  } catch (error) {
+    if (error instanceof TRPCError) throw error;
+    throw new TRPCError({
+      code: "BAD_GATEWAY",
+      message: error instanceof Error ? error.message : "Workshop is unavailable",
+      cause: error,
+    });
+  }
+}
+
+const workshopSearchInputSchema = z.object({
+  query: z.string().trim().min(1).max(200),
+  sort: z.enum(["top", "newest", "recent", "discussed"]).default("top"),
+  limit: z.number().int().min(1).max(20).default(10),
+});
+
+const sourceOverridesSchema = z.record(
+  customWidgetIdentifierSchema,
+  z.strictObject({
+    baseUrl: z.string(),
+    networkScope: z.enum(["public", "private", "loopback"]).optional(),
+  }),
+);
+
+export const workshopProcedures = {
+  workshopSearch: manageProcedure
+    .meta({ mcp: { enabled: true, description: "Search Workshop for Custom JSX widgets." } })
+    .input(workshopSearchInputSchema)
+    .query(async ({ input }) => {
+      try {
+        const result = await workshop.list({
+          page: 1,
+          perPage: input.limit,
+          search: input.query,
+          sort: input.sort,
+          type: "customWidget",
+          includeOutdated: true,
+        });
+        return {
+          items: result.items
+            .filter((item) => item.widgetSchema === CUSTOM_WIDGET_SCHEMA)
+            .map((item) => ({
+              id: item.id,
+              title: item.title,
+              description: item.description,
+              authorName: item.authorName,
+              score: item.score,
+              revision: item.revision,
+              outdated: item.outdated,
+              reportCount: item.reportCount,
+            })),
+        };
+      } catch (error) {
+        throw new TRPCError({
+          code: "BAD_GATEWAY",
+          message: error instanceof Error ? error.message : "Workshop is unavailable",
+          cause: error,
+        });
+      }
+    }),
+
+  workshopGet: manageProcedure
+    .meta({ mcp: { enabled: true, description: "Get and validate one Workshop Custom JSX widget." } })
+    .input(z.object({ submissionId: z.string().min(1) }))
+    .query(async ({ input }) => {
+      const { submission, widget } = await getWorkshopWidget(input.submissionId);
+      return {
+        submission: {
+          id: submission.id,
+          title: submission.title,
+          description: submission.description,
+          authorName: submission.authorName,
+          revision: submission.revision,
+          score: submission.score,
+          outdated: submission.outdated,
+          reportCount: submission.reportCount,
+        },
+        widget,
+        sourceSetup: getCustomWidgetSourceSetups(widget.sources),
+        hasActions: Object.values(widget.requests).some((request) => request.kind === "action"),
+        methods: [...new Set(Object.values(widget.requests).map((request) => request.method))],
+        permissions: [...new Set(Object.values(widget.requests).map((request) => request.permission))],
+      };
+    }),
+
+  workshopInstall: manageProcedure
+    .meta({ mcp: { enabled: true, description: "Install one validated Workshop Custom JSX widget." } })
+    .input(
+      z.object({
+        submissionId: z.string().min(1),
+        name: z.string().trim().min(1).max(128).optional(),
+        sources: sourceOverridesSchema.default({}),
+        secrets: customWidgetSecretsInputSchema.default([]),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      if (input.secrets.length > 0 && !ctx.session.user.permissions.includes("custom-widget-secret-write")) {
+        throw new TRPCError({
+          code: "FORBIDDEN",
+          message: "Writing Workshop widget credentials requires dedicated permission",
+        });
+      }
+      const { widget } = await getWorkshopWidget(input.submissionId);
+      const unknownSource = Object.keys(input.sources).find((sourceId) => !widget.sources[sourceId]);
+      if (unknownSource) {
+        throw new TRPCError({ code: "BAD_REQUEST", message: `Unknown Workshop widget source '${unknownSource}'` });
+      }
+      const configured = customWidgetDefinitionSchema.parse({
+        ...widget,
+        name: input.name ?? widget.name,
+        sources: applyCustomWidgetSourceSetup(
+          widget.sources,
+          Object.fromEntries(
+            Object.entries(input.sources).map(([sourceId, source]) => [
+              sourceId,
+              {
+                baseUrl: source.baseUrl,
+                networkScope: source.networkScope ?? widget.sources[sourceId]?.networkScope ?? "public",
+              },
+            ]),
+          ),
+        ),
+      });
+      assertSecretSources(configured.sources, input.secrets);
+      const id = await insertCustomWidgetDefinition(ctx.db, configured, ctx.session.user.id, input.secrets);
+      const configuredSecrets = new Set(input.secrets.map((secret) => `${secret.sourceId}:${secret.kind}`));
+      return {
+        status: "installed" as const,
+        definitionId: id,
+        sourceSetup: getCustomWidgetSourceSetups(configured.sources, input.secrets),
+        missingCredentials: getCustomWidgetSecretRequirements(configured.sources)
+          .filter((requirement) => !configuredSecrets.has(`${requirement.sourceId}:${requirement.kind}`))
+          .map(({ sourceId, kind }) => ({ sourceId, kind })),
+      };
+    }),
+};