@wopr-network/platform-core 1.68.0 → 1.70.0

package/dist/server/__tests__/container.test.js

@@ -0,0 +1,173 @@
+import { describe, expect, it } from "vitest";
+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 = {
+            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 = {
+            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 = {
+            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" },
+            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 = {
+            manager: {},
+            docker: {},
+            proxy: {},
+            profileStore: {},
+            serviceKeyRepo: {},
+        };
+        const crypto = {
+            chargeRepo: {},
+            webhookSeenRepo: {},
+        };
+        const stripe = {
+            stripe: {},
+            webhookSecret: "whsec_test",
+            customerRepo: {},
+            processor: {},
+        };
+        const gateway = {
+            serviceKeyRepo: {},
+        };
+        const hotPool = {
+            start: async () => ({ stop: () => { } }),
+            claim: async () => null,
+            getPoolSize: async () => 2,
+            setPoolSize: async () => { },
+        };
+        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: {} } });
+        // 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/dist/server/__tests__/lifecycle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/__tests__/lifecycle.test.js

@@ -0,0 +1,90 @@
+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: {},
+                docker: {},
+                proxy: {
+                    start: startFn,
+                    addRoute: async () => { },
+                    removeRoute: () => { },
+                    getRoutes: () => [],
+                },
+                profileStore: { list: async () => [] },
+                serviceKeyRepo: {},
+            },
+        });
+        await startBackgroundServices(container);
+        expect(startFn).toHaveBeenCalledOnce();
+    });
+    it("does not throw when proxy.start fails", async () => {
+        const container = createTestContainer({
+            fleet: {
+                manager: {},
+                docker: {},
+                proxy: {
+                    start: async () => {
+                        throw new Error("proxy start failed");
+                    },
+                    addRoute: async () => { },
+                    removeRoute: () => { },
+                    getRoutes: () => [],
+                },
+                profileStore: { list: async () => [] },
+                serviceKeyRepo: {},
+            },
+        });
+        // 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 },
+        });
+        const handles = { intervals: [], unsubscribes: [] };
+        await gracefulShutdown(container, handles);
+        expect(endFn).toHaveBeenCalledOnce();
+    });
+});

package/dist/server/__tests__/mount-routes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/__tests__/mount-routes.test.js

@@ -0,0 +1,151 @@
+import { Hono } from "hono";
+import { describe, expect, it } from "vitest";
+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) {
+    const app = new Hono();
+    mountRoutes(app, container, defaultMountConfig());
+    return app;
+}
+async function req(app, method, path, opts) {
+    const request = new Request(`http://localhost${path}`, { method, ...opts });
+    return app.request(request);
+}
+// ---------------------------------------------------------------------------
+// Minimal stubs for feature sub-containers
+// ---------------------------------------------------------------------------
+function stubCrypto() {
+    return {
+        chargeRepo: {},
+        webhookSeenRepo: {},
+    };
+}
+function stubStripe() {
+    return {
+        stripe: {},
+        webhookSecret: "whsec_test",
+        customerRepo: {},
+        processor: {
+            handleWebhook: async () => ({ ok: true }),
+        },
+    };
+}
+function stubFleet() {
+    return {
+        manager: {},
+        docker: {},
+        proxy: {
+            start: async () => { },
+            addRoute: async () => { },
+            removeRoute: () => { },
+            getRoutes: () => [],
+        },
+        profileStore: { list: async () => [] },
+        serviceKeyRepo: {},
+    };
+}
+// ---------------------------------------------------------------------------
+// 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/dist/server/boot-config.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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";
+export interface FeatureFlags {
+    fleet: boolean;
+    crypto: boolean;
+    stripe: boolean;
+    gateway: boolean;
+    hotPool: boolean;
+}
+export interface RoutePlugin {
+    path: string;
+    handler: (container: PlatformContainer) => Hono;
+}
+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;
+}
+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>;
+}

package/dist/server/boot-config.js

@@ -0,0 +1,7 @@
+/**
+ * BootConfig — declarative configuration for platformBoot().
+ *
+ * Products pass a BootConfig describing which features to enable and
+ * receive back a fully-wired Hono app + PlatformContainer.
+ */
+export {};

package/dist/server/container.d.ts

@@ -0,0 +1,97 @@
+/**
+ * PlatformContainer — the central DI container for platform-core.
+ *
+ * Products compose a container at boot time, enabling only the feature
+ * slices they need. Nullable sub-containers (fleet, crypto, stripe,
+ * gateway, hotPool) let each product opt in without pulling unused deps.
+ */
+import type Docker from "dockerode";
+import type { Pool } from "pg";
+import type Stripe from "stripe";
+import type { IUserRoleRepository } from "../auth/user-role-repository.js";
+import type { ICryptoChargeRepository } from "../billing/crypto/charge-store.js";
+import type { IWebhookSeenRepository } from "../billing/webhook-seen-repository.js";
+import type { ILedger } from "../credits/ledger.js";
+import type { ITenantCustomerRepository } from "../credits/tenant-customer-repository.js";
+import type { DrizzleDb } from "../db/index.js";
+import type { FleetManager } from "../fleet/fleet-manager.js";
+import type { IProfileStore } from "../fleet/profile-store.js";
+import type { IServiceKeyRepository } from "../gateway/service-key-repository.js";
+import type { ProductConfig } from "../product-config/repository-types.js";
+import type { ProxyManagerInterface } from "../proxy/types.js";
+import type { IOrgMemberRepository } from "../tenancy/org-member-repository.js";
+import type { OrgService } from "../tenancy/org-service.js";
+import type { BootConfig } from "./boot-config.js";
+export interface FleetServices {
+    manager: FleetManager;
+    docker: Docker;
+    proxy: ProxyManagerInterface;
+    profileStore: IProfileStore;
+    serviceKeyRepo: IServiceKeyRepository;
+}
+export interface CryptoServices {
+    chargeRepo: ICryptoChargeRepository;
+    webhookSeenRepo: IWebhookSeenRepository;
+}
+export interface StripeServices {
+    stripe: Stripe;
+    webhookSecret: string;
+    customerRepo: ITenantCustomerRepository;
+    processor: {
+        handleWebhook(payload: Buffer, signature: string): Promise<unknown>;
+    };
+}
+export interface GatewayServices {
+    serviceKeyRepo: IServiceKeyRepository;
+}
+export interface HotPoolServices {
+    /** Start the pool manager (replenish loop + cleanup). */
+    start: () => Promise<{
+        stop: () => void;
+    }>;
+    /** Claim a warm instance from the pool. Returns null if empty. */
+    claim: (name: string, tenantId: string, adminUser: {
+        id: string;
+        email: string;
+        name: string;
+    }) => Promise<{
+        id: string;
+        name: string;
+        subdomain: string;
+    } | null>;
+    /** Get current pool size from DB. */
+    getPoolSize: () => Promise<number>;
+    /** Set pool size in DB. */
+    setPoolSize: (size: number) => Promise<void>;
+}
+export interface PlatformContainer {
+    db: DrizzleDb;
+    pool: Pool;
+    productConfig: ProductConfig;
+    creditLedger: ILedger;
+    orgMemberRepo: IOrgMemberRepository;
+    orgService: OrgService;
+    userRoleRepo: IUserRoleRepository;
+    /** Null when the product does not use fleet management. */
+    fleet: FleetServices | null;
+    /** Null when the product does not accept crypto payments. */
+    crypto: CryptoServices | null;
+    /** Null when the product does not use Stripe billing. */
+    stripe: StripeServices | null;
+    /** Null when the product does not expose a metered inference gateway. */
+    gateway: GatewayServices | null;
+    /** Null when the product does not use a hot-pool of pre-provisioned instances. */
+    hotPool: HotPoolServices | null;
+}
+/**
+ * Build a fully-wired PlatformContainer from a declarative BootConfig.
+ *
+ * Construction order mirrors the proven boot sequence from product index.ts
+ * files: DB pool -> Drizzle -> migrations -> productConfig -> credit ledger
+ * -> org repos -> org service -> user role repo -> feature services.
+ *
+ * Feature sub-containers (fleet, crypto, stripe, gateway) are only
+ * constructed when their corresponding feature flag is enabled in
+ * `bootConfig.features`. Disabled features yield `null`.
+ */
+export declare function buildContainer(bootConfig: BootConfig): Promise<PlatformContainer>;