@wopr-network/platform-core 1.67.1 → 1.69.0

package/src/server/__tests__/container.test.ts

@@ -0,0 +1,204 @@
+import { describe, expect, it } from "vitest";
+import type { BootConfig, FeatureFlags } from "../boot-config.js";
+import type { CryptoServices, FleetServices, GatewayServices, HotPoolServices, StripeServices } from "../container.js";
+import { createTestContainer } from "../test-container.js";
+
+// ---------------------------------------------------------------------------
+// PlatformContainer interface
+// ---------------------------------------------------------------------------
+
+describe("PlatformContainer", () => {
+  it("allows null feature services", () => {
+    const c = createTestContainer();
+    expect(c.fleet).toBeNull();
+    expect(c.crypto).toBeNull();
+    expect(c.stripe).toBeNull();
+    expect(c.gateway).toBeNull();
+    expect(c.hotPool).toBeNull();
+  });
+
+  it("requires core services to be present", () => {
+    const c = createTestContainer();
+    expect(c.db).toBeDefined();
+    expect(c.pool).toBeDefined();
+    expect(c.productConfig).toBeDefined();
+    expect(c.creditLedger).toBeDefined();
+    expect(c.orgMemberRepo).toBeDefined();
+    expect(c.orgService).toBeDefined();
+    expect(c.userRoleRepo).toBeDefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// BootConfig shape
+// ---------------------------------------------------------------------------
+
+describe("BootConfig", () => {
+  it("requires slug and provisionSecret", () => {
+    const config: BootConfig = {
+      slug: "test-product",
+      databaseUrl: "postgres://localhost/test",
+      provisionSecret: "s3cret",
+      features: {
+        fleet: false,
+        crypto: false,
+        stripe: false,
+        gateway: false,
+        hotPool: false,
+      },
+    };
+
+    expect(config.slug).toBe("test-product");
+    expect(config.provisionSecret).toBe("s3cret");
+  });
+
+  it("accepts optional fields", () => {
+    const config: BootConfig = {
+      slug: "full",
+      databaseUrl: "postgres://localhost/full",
+      provisionSecret: "secret",
+      host: "127.0.0.1",
+      port: 4000,
+      features: {
+        fleet: true,
+        crypto: true,
+        stripe: true,
+        gateway: true,
+        hotPool: true,
+      },
+      stripeSecretKey: "sk_test_xxx",
+      stripeWebhookSecret: "whsec_xxx",
+      cryptoServiceKey: "csk_xxx",
+      routes: [],
+    };
+
+    expect(config.host).toBe("127.0.0.1");
+    expect(config.port).toBe(4000);
+    expect(config.features.fleet).toBe(true);
+  });
+
+  it("FeatureFlags has all five toggles", () => {
+    const flags: FeatureFlags = {
+      fleet: true,
+      crypto: false,
+      stripe: true,
+      gateway: false,
+      hotPool: true,
+    };
+
+    expect(Object.keys(flags)).toHaveLength(5);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createTestContainer
+// ---------------------------------------------------------------------------
+
+describe("createTestContainer", () => {
+  it("returns valid defaults", () => {
+    const c = createTestContainer();
+
+    expect(c.fleet).toBeNull();
+    expect(c.crypto).toBeNull();
+    expect(c.stripe).toBeNull();
+    expect(c.gateway).toBeNull();
+    expect(c.hotPool).toBeNull();
+    expect(c.productConfig.product).toBeDefined();
+  });
+
+  it("allows overrides for core services", () => {
+    const customConfig = {
+      product: { slug: "custom", name: "Custom" } as never,
+      navItems: [],
+      domains: [],
+      features: null,
+      fleet: null,
+      billing: null,
+    };
+
+    const c = createTestContainer({ productConfig: customConfig });
+    expect(c.productConfig.product).toEqual({ slug: "custom", name: "Custom" });
+  });
+
+  it("stub ledger methods return sensible defaults", async () => {
+    const c = createTestContainer();
+
+    expect(await c.creditLedger.balance("t1")).toBe(0);
+    expect(await c.creditLedger.hasReferenceId("ref")).toBe(false);
+    expect(await c.creditLedger.history("t1")).toEqual([]);
+    expect(await c.creditLedger.tenantsWithBalance()).toEqual([]);
+    expect(await c.creditLedger.lifetimeSpendBatch([])).toEqual(new Map());
+  });
+
+  it("stub orgMemberRepo methods return sensible defaults", async () => {
+    const c = createTestContainer();
+
+    expect(await c.orgMemberRepo.findMember("org1", "u1")).toBeNull();
+    expect(await c.orgMemberRepo.listMembers("org1")).toEqual([]);
+    expect(await c.orgMemberRepo.countAdminsAndOwners("org1")).toBe(0);
+  });
+
+  it("stub userRoleRepo methods return sensible defaults", async () => {
+    const c = createTestContainer();
+
+    expect(await c.userRoleRepo.getTenantIdByUserId("u1")).toBeNull();
+    expect(await c.userRoleRepo.isPlatformAdmin("u1")).toBe(false);
+    expect(await c.userRoleRepo.listRolesByUser("u1")).toEqual([]);
+  });
+
+  it("allows enabling feature services via overrides", () => {
+    const fleet: FleetServices = {
+      manager: {} as never,
+      docker: {} as never,
+      proxy: {} as never,
+      profileStore: {} as never,
+      serviceKeyRepo: {} as never,
+    };
+
+    const crypto: CryptoServices = {
+      chargeRepo: {} as never,
+      webhookSeenRepo: {} as never,
+    };
+
+    const stripe: StripeServices = {
+      stripe: {} as never,
+      webhookSecret: "whsec_test",
+      customerRepo: {} as never,
+      processor: {} as never,
+    };
+
+    const gateway: GatewayServices = {
+      serviceKeyRepo: {} as never,
+    };
+
+    const hotPool: HotPoolServices = {
+      poolManager: {},
+    };
+
+    const c = createTestContainer({ fleet, crypto, stripe, gateway, hotPool });
+
+    expect(c.fleet).not.toBeNull();
+    expect(c.crypto).not.toBeNull();
+    expect(c.stripe).not.toBeNull();
+    expect(c.stripe?.webhookSecret).toBe("whsec_test");
+    expect(c.gateway).not.toBeNull();
+    expect(c.hotPool).not.toBeNull();
+  });
+
+  it("overrides merge without affecting other defaults", () => {
+    const c = createTestContainer({ gateway: { serviceKeyRepo: {} as never } });
+
+    // Overridden field
+    expect(c.gateway).not.toBeNull();
+
+    // Other feature services remain null
+    expect(c.fleet).toBeNull();
+    expect(c.crypto).toBeNull();
+    expect(c.stripe).toBeNull();
+    expect(c.hotPool).toBeNull();
+
+    // Core services still present
+    expect(c.creditLedger).toBeDefined();
+    expect(c.orgMemberRepo).toBeDefined();
+  });
+});

package/src/server/__tests__/lifecycle.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it, vi } from "vitest";
+import { gracefulShutdown, startBackgroundServices } from "../lifecycle.js";
+import { createTestContainer } from "../test-container.js";
+
+describe("startBackgroundServices", () => {
+  it("returns a BackgroundHandles object", async () => {
+    const container = createTestContainer();
+    const handles = await startBackgroundServices(container);
+    expect(handles).toHaveProperty("intervals");
+    expect(handles).toHaveProperty("unsubscribes");
+    expect(Array.isArray(handles.intervals)).toBe(true);
+    expect(Array.isArray(handles.unsubscribes)).toBe(true);
+  });
+
+  it("calls proxy.start when fleet is enabled", async () => {
+    const startFn = vi.fn().mockResolvedValue(undefined);
+    const container = createTestContainer({
+      fleet: {
+        manager: {} as never,
+        docker: {} as never,
+        proxy: {
+          start: startFn,
+          addRoute: async () => {},
+          removeRoute: () => {},
+          getRoutes: () => [],
+        } as never,
+        profileStore: { list: async () => [] } as never,
+        serviceKeyRepo: {} as never,
+      },
+    });
+    await startBackgroundServices(container);
+    expect(startFn).toHaveBeenCalledOnce();
+  });
+
+  it("does not throw when proxy.start fails", async () => {
+    const container = createTestContainer({
+      fleet: {
+        manager: {} as never,
+        docker: {} as never,
+        proxy: {
+          start: async () => {
+            throw new Error("proxy start failed");
+          },
+          addRoute: async () => {},
+          removeRoute: () => {},
+          getRoutes: () => [],
+        } as never,
+        profileStore: { list: async () => [] } as never,
+        serviceKeyRepo: {} as never,
+      },
+    });
+    // Should not throw
+    const handles = await startBackgroundServices(container);
+    expect(handles).toBeDefined();
+  });
+});
+
+describe("gracefulShutdown", () => {
+  it("clears all intervals", async () => {
+    const container = createTestContainer();
+    const clearSpy = vi.spyOn(global, "clearInterval");
+
+    const interval1 = setInterval(() => {}, 10000);
+    const interval2 = setInterval(() => {}, 10000);
+
+    const handles = {
+      intervals: [interval1, interval2],
+      unsubscribes: [],
+    };
+
+    await gracefulShutdown(container, handles);
+
+    expect(clearSpy).toHaveBeenCalledWith(interval1);
+    expect(clearSpy).toHaveBeenCalledWith(interval2);
+    clearSpy.mockRestore();
+  });
+
+  it("calls all unsubscribe functions", async () => {
+    const container = createTestContainer();
+    const unsub1 = vi.fn();
+    const unsub2 = vi.fn();
+
+    const handles = {
+      intervals: [],
+      unsubscribes: [unsub1, unsub2],
+    };
+
+    await gracefulShutdown(container, handles);
+
+    expect(unsub1).toHaveBeenCalledOnce();
+    expect(unsub2).toHaveBeenCalledOnce();
+  });
+
+  it("calls pool.end()", async () => {
+    const endFn = vi.fn().mockResolvedValue(undefined);
+    const container = createTestContainer({
+      pool: { end: endFn } as never,
+    });
+
+    const handles = { intervals: [], unsubscribes: [] };
+
+    await gracefulShutdown(container, handles);
+
+    expect(endFn).toHaveBeenCalledOnce();
+  });
+});

package/src/server/__tests__/mount-routes.test.ts

@@ -0,0 +1,169 @@
+import { Hono } from "hono";
+import { describe, expect, it } from "vitest";
+import type { PlatformContainer } from "../container.js";
+import { mountRoutes } from "../mount-routes.js";
+import { createTestContainer } from "../test-container.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function defaultMountConfig() {
+  return {
+    provisionSecret: "test-secret",
+    cryptoServiceKey: "test-crypto-key",
+    platformDomain: "example.com",
+  };
+}
+
+function makeApp(container: PlatformContainer) {
+  const app = new Hono();
+  mountRoutes(app, container, defaultMountConfig());
+  return app;
+}
+
+async function req(app: Hono, method: string, path: string, opts?: RequestInit) {
+  const request = new Request(`http://localhost${path}`, { method, ...opts });
+  return app.request(request);
+}
+
+// ---------------------------------------------------------------------------
+// Minimal stubs for feature sub-containers
+// ---------------------------------------------------------------------------
+
+function stubCrypto(): PlatformContainer["crypto"] {
+  return {
+    chargeRepo: {} as never,
+    webhookSeenRepo: {} as never,
+  };
+}
+
+function stubStripe(): PlatformContainer["stripe"] {
+  return {
+    stripe: {} as never,
+    webhookSecret: "whsec_test",
+    customerRepo: {} as never,
+    processor: {
+      handleWebhook: async () => ({ ok: true }),
+    },
+  };
+}
+
+function stubFleet(): PlatformContainer["fleet"] {
+  return {
+    manager: {} as never,
+    docker: {} as never,
+    proxy: {
+      start: async () => {},
+      addRoute: async () => {},
+      removeRoute: () => {},
+      getRoutes: () => [],
+    } as never,
+    profileStore: { list: async () => [] } as never,
+    serviceKeyRepo: {} as never,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("mountRoutes", () => {
+  // 1. Health endpoint always available
+  it("mounts /health endpoint", async () => {
+    const app = makeApp(createTestContainer());
+    const res = await req(app, "GET", "/health");
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ ok: true });
+  });
+
+  // 2. Crypto webhook mounted when crypto enabled
+  it("mounts crypto webhook when crypto enabled", async () => {
+    const container = createTestContainer({ crypto: stubCrypto() });
+    const app = makeApp(container);
+    const res = await req(app, "POST", "/api/webhooks/crypto", {
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    // Should return 401 (no auth), NOT 404 (not found)
+    expect(res.status).toBe(401);
+  });
+
+  // 3. Crypto webhook NOT mounted when crypto disabled
+  it("does not mount crypto webhook when crypto disabled", async () => {
+    const container = createTestContainer({ crypto: null });
+    const app = makeApp(container);
+    const res = await req(app, "POST", "/api/webhooks/crypto", {
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    expect(res.status).toBe(404);
+  });
+
+  // 4. Stripe webhook mounted when stripe enabled
+  it("mounts stripe webhook when stripe enabled", async () => {
+    const container = createTestContainer({ stripe: stubStripe() });
+    const app = makeApp(container);
+    const res = await req(app, "POST", "/api/webhooks/stripe", {
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    // Should return 400 (missing stripe-signature), NOT 404
+    expect(res.status).toBe(400);
+  });
+
+  // 5. Stripe webhook NOT mounted when stripe disabled
+  it("does not mount stripe webhook when stripe disabled", async () => {
+    const container = createTestContainer({ stripe: null });
+    const app = makeApp(container);
+    const res = await req(app, "POST", "/api/webhooks/stripe", {
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    expect(res.status).toBe(404);
+  });
+
+  // 6. Provision webhook mounted when fleet enabled
+  it("mounts provision webhook when fleet enabled", async () => {
+    const container = createTestContainer({ fleet: stubFleet() });
+    const app = makeApp(container);
+    const res = await req(app, "POST", "/api/provision/create", {
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    // Should return 401 (no auth), NOT 404
+    expect(res.status).toBe(401);
+  });
+
+  // 7. Provision webhook NOT mounted when fleet disabled
+  it("does not mount provision webhook when fleet disabled", async () => {
+    const container = createTestContainer({ fleet: null });
+    const app = makeApp(container);
+    const res = await req(app, "POST", "/api/provision/create", {
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({}),
+    });
+    expect(res.status).toBe(404);
+  });
+
+  // 8. Product-specific route plugins
+  it("mounts product-specific route plugins", async () => {
+    const container = createTestContainer();
+    const app = new Hono();
+    mountRoutes(app, container, defaultMountConfig(), [
+      {
+        path: "/api/custom",
+        handler: () => {
+          const sub = new Hono();
+          sub.get("/ping", (c) => c.json({ pong: true }));
+          return sub;
+        },
+      },
+    ]);
+    const res = await req(app, "GET", "/api/custom/ping");
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ pong: true });
+  });
+});

package/src/server/boot-config.ts

@@ -0,0 +1,84 @@
+/**
+ * BootConfig — declarative configuration for platformBoot().
+ *
+ * Products pass a BootConfig describing which features to enable and
+ * receive back a fully-wired Hono app + PlatformContainer.
+ */
+
+import type { Hono } from "hono";
+import type { PlatformContainer } from "./container.js";
+
+// ---------------------------------------------------------------------------
+// Feature flags
+// ---------------------------------------------------------------------------
+
+export interface FeatureFlags {
+  fleet: boolean;
+  crypto: boolean;
+  stripe: boolean;
+  gateway: boolean;
+  hotPool: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Route plugins
+// ---------------------------------------------------------------------------
+
+export interface RoutePlugin {
+  path: string;
+  handler: (container: PlatformContainer) => Hono;
+}
+
+// ---------------------------------------------------------------------------
+// Boot config
+// ---------------------------------------------------------------------------
+
+export interface BootConfig {
+  /** Short product identifier (e.g. "paperclip", "wopr", "holyship"). */
+  slug: string;
+
+  /** PostgreSQL connection string. */
+  databaseUrl: string;
+
+  /** Bind host (default "0.0.0.0"). */
+  host?: string;
+
+  /** Bind port (default 3001). */
+  port?: number;
+
+  /** Which optional feature slices to wire up. */
+  features: FeatureFlags;
+
+  /** Additional Hono sub-apps mounted after core routes. */
+  routes?: RoutePlugin[];
+
+  /** Required when features.stripe is true. */
+  stripeSecretKey?: string;
+
+  /** Required when features.stripe is true. */
+  stripeWebhookSecret?: string;
+
+  /** Service key for the crypto chain server webhook endpoint. */
+  cryptoServiceKey?: string;
+
+  /** Shared secret used to authenticate provision requests. */
+  provisionSecret: string;
+}
+
+// ---------------------------------------------------------------------------
+// Boot result
+// ---------------------------------------------------------------------------
+
+export interface BootResult {
+  /** The fully-wired Hono application. */
+  app: Hono;
+
+  /** The assembled DI container — useful for tests and ad-hoc access. */
+  container: PlatformContainer;
+
+  /** Start listening. Uses BootConfig.port unless overridden. */
+  start: (port?: number) => Promise<void>;
+
+  /** Graceful shutdown: drain connections, close pool. */
+  stop: () => Promise<void>;
+}