@cosmicdrift/kumiko-bundled-features 0.296.0 → 0.299.0

package/src/subscription-stripe/__tests__/stripe-foundation.integration.test.ts

@@ -16,12 +16,11 @@ import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 import { randomBytes } from "node:crypto";
 import {
   billingFoundationFeature,
-  createSubscriptionWebhookHandler,
-  type SubscriptionProviderPlugin,
+  createSubscriptionWebhookRoute,
   subscriptionAggregateId,
 } from "@cosmicdrift/kumiko-bundled-features/billing-foundation";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import { SYSTEM_TENANT_ID, type TenantId } from "@cosmicdrift/kumiko-framework/engine";
+import { SYSTEM_TENANT_ID } from "@cosmicdrift/kumiko-framework/engine";
 import { loadAggregate } from "@cosmicdrift/kumiko-framework/event-store";
 import { createEnvMasterKeyProvider } from "@cosmicdrift/kumiko-framework/secrets";
 import {
@@ -33,18 +32,12 @@ import {
   unsafePushTables,
 } from "@cosmicdrift/kumiko-framework/stack";
 import { createTestEnvelopeCipher } from "@cosmicdrift/kumiko-framework/testing";
-import { Hono } from "hono";
 import Stripe from "stripe";
 import { createComplianceProfilesFeature } from "../../compliance-profiles";
 import { configValuesTable, createConfigFeature } from "../../config";
 import { createConfigAccessorFactory } from "../../config/feature";
 import { createConfigResolver } from "../../config/resolver";
-import {
-  createSecretsContext,
-  createSecretsFeature,
-  type SecretsContext,
-  tenantSecretsTable,
-} from "../../secrets";
+import { createSecretsContext, createSecretsFeature, tenantSecretsTable } from "../../secrets";
 import { createTenantFeature } from "../../tenant/feature";
 import { tenantEntity } from "../../tenant/schema/tenant";
 import { createTenantLifecycleFeature } from "../../tenant-lifecycle";
@@ -67,11 +60,6 @@ const PRICE_TO_TIER = { price_pro_monthly: "pro", price_business_yearly: "busine
 
 let stack: TestStack;
 let db: DbConnection;
-let webhookApp: Hono;
-/** Zweite webhook-app MIT system-secrets gewired — für Scenario 5
- *  (runtime-secret-Pfad). */
-let webhookAppWithSecrets: Hono;
-let secretsCtx: SecretsContext;
 
 const stripeForFixtures = new Stripe(TEST_API_KEY);
 
@@ -109,8 +97,15 @@ beforeAll(async () => {
       configResolver: resolver,
       configEncryption: encryption,
       _configAccessorFactory: createConfigAccessorFactory(registry, resolver),
+      // Forwarded to every signature extraRoute's verify()/handler() as
+      // `deps.secrets` — one webhook route now serves both the factory-
+      // fallback scenarios (1–4, no row seeded yet) and the runtime-secret
+      // scenario (5, seeded via config:write:set) since runtime.ts's
+      // resolver already falls back to the factory options when the store
+      // is empty.
       secrets: createSecretsContext({ db: ctxDb, masterKeyProvider }),
     }),
+    extraRoutes: [createSubscriptionWebhookRoute()],
   });
   db = stack.db;
   // subscriptionsProjectionTable wird von setupTestStack automatisch
@@ -118,46 +113,6 @@ beforeAll(async () => {
   // secrets brauchen ihre Tabellen explizit.
   await unsafeCreateEntityTable(db, tenantEntity);
   await unsafePushTables(db, { configValuesTable, tenant_secrets: tenantSecretsTable });
-  // Standalone-secrets-context (gleiche KEK) zum direkten Seeden +
-  // als systemSecrets für die zweite webhook-app.
-  secretsCtx = createSecretsContext({ db, masterKeyProvider });
-
-  // Webhook-app: Hono mit der webhook-handler-Route.
-  // dispatchWrite ruft `stack.http.write` mit dem System-User des
-  // resolved-Tenants — das ist exakt was der App-Builder im echten
-  // bin/server.ts via extraRoutes wireup macht. `systemSecrets` optional:
-  // ohne → factory-fallback-Pfad (Scenarios 1–4); mit → runtime-secret-
-  // Pfad (Scenario 5), exakt wie der App-Owner createSecretsContext wired.
-  const mountWebhook = (systemSecrets?: SecretsContext): Hono => {
-    const app = new Hono();
-    app.post(
-      "/api/subscription/webhook/:providerName",
-      createSubscriptionWebhookHandler({
-        dispatchWrite: async ({ handlerQn, payload, tenantId }) => {
-          const systemUser = createTestUser({
-            id: 1,
-            tenantId: tenantId as TenantId,
-            roles: ["SystemAdmin"],
-          });
-          const res = await stack.http.write(handlerQn, payload, systemUser);
-          const body = await res.json();
-          return body.isSuccess
-            ? { isSuccess: true, data: body.data }
-            : { isSuccess: false, error: body.error };
-        },
-        resolveProvider: (providerName) => {
-          const usage = stack.registry
-            .getExtensionUsages("subscriptionProvider")
-            .find((u) => u.entityName === providerName);
-          return usage?.options as SubscriptionProviderPlugin | undefined;
-        },
-        ...(systemSecrets && { systemSecrets }),
-      }),
-    );
-    return app;
-  };
-  webhookApp = mountWebhook();
-  webhookAppWithSecrets = mountWebhook(secretsCtx);
 });
 
 afterAll(async () => {
@@ -218,8 +173,8 @@ async function signEvent(payload: string, secret = TEST_SECRET): Promise<string>
   });
 }
 
-async function postStripeWebhook(payload: string, sig: string, app: Hono = webhookApp) {
-  return app.request("/api/subscription/webhook/stripe", {
+async function postStripeWebhook(payload: string, sig: string) {
+  return stack.app.request("/api/subscription/webhook/stripe", {
     method: "POST",
     body: payload,
     headers: { "stripe-signature": sig, "content-type": "application/json" },
@@ -298,8 +253,11 @@ describe("scenario 2: invalid sig → 401, kein DB-write", () => {
 
     const res = await postStripeWebhook(payload, wrongSig);
     expect(res.status).toBe(401);
+    // extraRoutes' generic signature-rejection code (kumiko-framework#3050)
+    // — verify() throws a plain Error on sig mismatch, buildServer maps any
+    // non-ExtraRouteRejection throw from verify() to this code.
     const body = (await res.json()) as { error: { code: string } };
-    expect(body.error.code).toBe("subscription_webhook_signature_invalid");
+    expect(body.error.code).toBe("extra_route_signature_invalid");
 
     // Drift-pin: foundation-DB ist unberührt — kein subscription-row
     // für diesen Tenant entstanden.
@@ -427,7 +385,7 @@ describe("scenario 5: runtime-secret resolution", () => {
     // fallback (TEST_SECRET) nutzen, schlüge die Verifikation fehl.
     const sig = await signEvent(payload, SEEDED_WEBHOOK_SECRET);
 
-    const res = await postStripeWebhook(payload, sig, webhookAppWithSecrets);
+    const res = await postStripeWebhook(payload, sig);
     expect(res.status).toBe(200);
 
     const admin = createTestUser({
@@ -452,7 +410,7 @@ describe("scenario 5: runtime-secret resolution", () => {
       buildStripeSubscriptionEvent({ eventId: "evt_4005_stale", tenantId: testTenantId(4006) }),
     );
     const sigWithStaleFallback = await signEvent(payload, TEST_SECRET);
-    const res = await postStripeWebhook(payload, sigWithStaleFallback, webhookAppWithSecrets);
+    const res = await postStripeWebhook(payload, sigWithStaleFallback);
     expect(res.status).toBe(401);
   });
 });

package/src/billing-foundation/__tests__/webhook-handler.test.ts

@@ -1,200 +0,0 @@
-// Unit-Tests für createSubscriptionWebhookHandler. Treibt alle 5
-// HTTP-Pfade durch (400/401/404/500 + 200) via Hono `app.request()` —
-// ohne setupTestStack, weil der webhook-handler nur über die deps-
-// injection geht und keinen DB-roundtrip braucht.
-
-import { describe, expect, mock, test } from "bun:test";
-import { Hono } from "hono";
-import { SubscriptionEventTypes, SubscriptionStatuses } from "../constants";
-import type { SubscriptionEvent, SubscriptionProviderPlugin } from "../types";
-import { createSubscriptionWebhookHandler, type SubscriptionWebhookDeps } from "../webhook-handler";
-
-// =============================================================================
-// Test-helpers
-// =============================================================================
-
-function buildEvent(): SubscriptionEvent {
-  return {
-    providerEventId: "evt_test_001",
-    providerName: "stripe",
-    type: SubscriptionEventTypes.created,
-    tenantId: "tenant-test",
-    providerCustomerId: "cus_test",
-    providerSubscriptionId: "sub_test",
-    status: SubscriptionStatuses.active,
-    tier: "pro",
-    currentPeriodEnd: "2026-06-01T00:00:00Z",
-    rawPayload: '{"raw":"payload"}',
-  };
-}
-
-function buildPlugin(
-  overrides: Partial<SubscriptionProviderPlugin> = {},
-): SubscriptionProviderPlugin {
-  return {
-    verifyAndParseWebhook: async () => buildEvent(),
-    ...overrides,
-  };
-}
-
-function buildDeps(overrides: Partial<SubscriptionWebhookDeps> = {}): SubscriptionWebhookDeps {
-  return {
-    dispatchWrite: async () => ({ isSuccess: true, data: { duplicate: false } }),
-    resolveProvider: () => buildPlugin(),
-    ...overrides,
-  };
-}
-
-function buildApp(deps: SubscriptionWebhookDeps) {
-  const app = new Hono();
-  app.post("/api/subscription/webhook/:providerName", createSubscriptionWebhookHandler(deps));
-  return app;
-}
-
-async function postWebhook(app: Hono, providerName: string, body = '{"id":"evt_test"}') {
-  return app.request(`/api/subscription/webhook/${providerName}`, {
-    method: "POST",
-    body,
-    headers: { "stripe-signature": "test_sig" },
-  });
-}
-
-// =============================================================================
-// Happy path — 200 OK + processed
-// =============================================================================
-
-describe("webhook-handler — happy path", () => {
-  test("verifyAndParseWebhook → SubscriptionEvent → dispatchWrite → 200 processed", async () => {
-    const dispatchWrite = mock(async () => ({
-      isSuccess: true,
-      data: { duplicate: false, eventAggregateId: "evt-id" },
-    }));
-    const app = buildApp(buildDeps({ dispatchWrite }));
-
-    const res = await postWebhook(app, "stripe");
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as { processed: boolean; duplicate: boolean };
-    expect(body.processed).toBe(true);
-    expect(body.duplicate).toBe(false);
-
-    expect(dispatchWrite).toHaveBeenCalledTimes(1);
-    expect(dispatchWrite).toHaveBeenCalledWith(
-      expect.objectContaining({
-        handlerQn: "billing-foundation:write:process-event",
-        tenantId: "tenant-test",
-        payload: expect.objectContaining({
-          providerEventId: "evt_test_001",
-          providerName: "stripe",
-          type: "subscription.created",
-          tier: "pro",
-        }),
-      }),
-    );
-  });
-
-  test("plugin returns null (= unbekannter event-type) → 200 ignored, kein dispatch", async () => {
-    const dispatchWrite = mock();
-    const plugin = buildPlugin({ verifyAndParseWebhook: async () => null });
-    const app = buildApp(buildDeps({ dispatchWrite, resolveProvider: () => plugin }));
-
-    const res = await postWebhook(app, "stripe");
-    expect(res.status).toBe(200);
-    const body = (await res.json()) as { ignored: boolean };
-    expect(body.ignored).toBe(true);
-    expect(dispatchWrite).not.toHaveBeenCalled();
-  });
-});
-
-// =============================================================================
-// Error paths — 400/401/404/500
-// =============================================================================
-
-describe("webhook-handler — error paths", () => {
-  test("provider not registered → 404 mit subscription_provider_not_registered", async () => {
-    const app = buildApp(buildDeps({ resolveProvider: () => undefined }));
-
-    const res = await postWebhook(app, "ghost");
-    expect(res.status).toBe(404);
-    // Drift-Pin: error-code stable damit Stripe-/Mollie-retry-Logik
-    // sich auf den Code verlassen kann.
-    const body = (await res.json()) as { error: { code: string; message: string } };
-    expect(body.error.code).toBe("subscription_provider_not_registered");
-    expect(body.error.message).toMatch(/ghost/);
-  });
-
-  test("plugin throws beim sig-verify → 401 mit subscription_webhook_signature_invalid", async () => {
-    const plugin = buildPlugin({
-      verifyAndParseWebhook: async () => {
-        throw new Error("HMAC mismatch — wrong webhook secret?");
-      },
-    });
-    const app = buildApp(buildDeps({ resolveProvider: () => plugin }));
-
-    const res = await postWebhook(app, "stripe");
-    expect(res.status).toBe(401);
-    const body = (await res.json()) as { error: { code: string; message: string } };
-    expect(body.error.code).toBe("subscription_webhook_signature_invalid");
-    expect(body.error.message).toMatch(/HMAC mismatch/);
-  });
-
-  test("dispatchWrite returns isSuccess: false → 500 mit subscription_webhook_processing_failed", async () => {
-    const dispatchWrite = mock(async () => ({
-      isSuccess: false,
-      error: { code: "internal_error", message: "DB unavailable" },
-    }));
-    const app = buildApp(buildDeps({ dispatchWrite }));
-
-    const res = await postWebhook(app, "stripe");
-    expect(res.status).toBe(500);
-    const body = (await res.json()) as {
-      error: { code: string; message: string; details: unknown };
-    };
-    expect(body.error.code).toBe("subscription_webhook_processing_failed");
-    // Provider sees 500 + retries — that's the design (transient failure).
-    expect(body.error.details).toMatchObject({ code: "internal_error" });
-  });
-});
-
-// =============================================================================
-// Mounting-Pattern
-// =============================================================================
-
-describe("webhook-handler — Mounting-Pattern", () => {
-  test("Multi-Provider: zwei verschiedene URL-Pfade → unterschiedliche plugins", async () => {
-    // Drift-Pin für die Multi-Provider-Architektur: stripe-Plugin hat
-    // einen anderen verifyAndParseWebhook als paypal-Plugin. Wenn ein
-    // Refactor den path-segment-Lookup auf etwas anderes umstellt
-    // (z.B. globaler config-key wieder), würde dieser Test failen.
-    const stripeCalls: string[] = [];
-    const paypalCalls: string[] = [];
-    const stripePlugin = buildPlugin({
-      verifyAndParseWebhook: async () => {
-        stripeCalls.push("called");
-        return buildEvent();
-      },
-    });
-    const paypalPlugin = buildPlugin({
-      verifyAndParseWebhook: async () => {
-        paypalCalls.push("called");
-        return { ...buildEvent(), providerName: "paypal", providerEventId: "I-PAYPAL-001" };
-      },
-    });
-    const app = buildApp(
-      buildDeps({
-        resolveProvider: (name) => {
-          if (name === "stripe") return stripePlugin;
-          if (name === "paypal") return paypalPlugin;
-          return undefined;
-        },
-      }),
-    );
-
-    const stripeRes = await postWebhook(app, "stripe");
-    const paypalRes = await postWebhook(app, "paypal");
-
-    expect(stripeRes.status).toBe(200);
-    expect(paypalRes.status).toBe(200);
-    expect(stripeCalls).toHaveLength(1);
-    expect(paypalCalls).toHaveLength(1);
-  });
-});