@wopr-network/platform-core 1.58.1 → 1.60.0

package/dist/product-config/service.test.js

@@ -0,0 +1,107 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ProductConfigService } from "./service.js";
+function makeConfig(slug) {
+    const product = {
+        id: "test-id",
+        slug,
+        brandName: "Test",
+        productName: "Test",
+        tagline: "",
+        domain: "test.com",
+        appDomain: "app.test.com",
+        cookieDomain: ".test.com",
+        companyLegal: "",
+        priceLabel: "",
+        defaultImage: "",
+        emailSupport: "",
+        emailPrivacy: "",
+        emailLegal: "",
+        fromEmail: "",
+        homePath: "/dashboard",
+        storagePrefix: "test",
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    };
+    return { product, navItems: [], domains: [], features: null, fleet: null, billing: null };
+}
+function mockRepo() {
+    return {
+        getBySlug: vi.fn().mockResolvedValue(makeConfig("test")),
+        listAll: vi.fn().mockResolvedValue([makeConfig("test")]),
+        upsertProduct: vi.fn().mockResolvedValue(makeConfig("test").product),
+        replaceNavItems: vi.fn().mockResolvedValue(undefined),
+        upsertFeatures: vi.fn().mockResolvedValue(undefined),
+        upsertFleetConfig: vi.fn().mockResolvedValue(undefined),
+        upsertBillingConfig: vi.fn().mockResolvedValue(undefined),
+    };
+}
+describe("ProductConfigService", () => {
+    let repo;
+    let service;
+    beforeEach(() => {
+        repo = mockRepo();
+        service = new ProductConfigService(repo, { ttlMs: 100 });
+    });
+    // --- Cache behavior ---
+    it("caches getBySlug results", async () => {
+        await service.getBySlug("test");
+        await service.getBySlug("test");
+        expect(repo.getBySlug).toHaveBeenCalledOnce();
+    });
+    it("refetches after TTL expires", async () => {
+        await service.getBySlug("test");
+        await new Promise((r) => setTimeout(r, 150));
+        await service.getBySlug("test");
+        expect(repo.getBySlug).toHaveBeenCalledTimes(2);
+    });
+    it("does not cache null results", async () => {
+        repo.getBySlug.mockResolvedValue(null);
+        await service.getBySlug("missing");
+        await service.getBySlug("missing");
+        expect(repo.getBySlug).toHaveBeenCalledTimes(2);
+    });
+    // --- Auto-invalidation ---
+    it("upsertProduct invalidates cache", async () => {
+        await service.getBySlug("test");
+        expect(repo.getBySlug).toHaveBeenCalledOnce();
+        await service.upsertProduct("test", { brandName: "Updated" });
+        await service.getBySlug("test");
+        expect(repo.getBySlug).toHaveBeenCalledTimes(2);
+    });
+    it("replaceNavItems invalidates cache", async () => {
+        await service.getBySlug("test");
+        await service.replaceNavItems("test", "test-id", []);
+        await service.getBySlug("test");
+        expect(repo.getBySlug).toHaveBeenCalledTimes(2);
+    });
+    it("upsertFeatures invalidates cache", async () => {
+        await service.getBySlug("test");
+        await service.upsertFeatures("test", "test-id", { chatEnabled: false });
+        await service.getBySlug("test");
+        expect(repo.getBySlug).toHaveBeenCalledTimes(2);
+    });
+    it("upsertFleetConfig invalidates cache", async () => {
+        await service.getBySlug("test");
+        await service.upsertFleetConfig("test", "test-id", { lifecycle: "ephemeral" });
+        await service.getBySlug("test");
+        expect(repo.getBySlug).toHaveBeenCalledTimes(2);
+    });
+    it("upsertBillingConfig invalidates cache", async () => {
+        await service.getBySlug("test");
+        await service.upsertBillingConfig("test", "test-id", { affiliateMaxCap: 100 });
+        await service.getBySlug("test");
+        expect(repo.getBySlug).toHaveBeenCalledTimes(2);
+    });
+    // --- Brand config derivation ---
+    it("getBrandConfig returns derived brand config", async () => {
+        const brand = await service.getBrandConfig("test");
+        expect(brand).not.toBeNull();
+        expect(brand?.brandName).toBe("Test");
+        expect(brand?.domain).toBe("test.com");
+    });
+    it("getBrandConfig returns null for missing product", async () => {
+        repo.getBySlug.mockResolvedValue(null);
+        const brand = await service.getBrandConfig("missing");
+        expect(brand).toBeNull();
+    });
+});

package/dist/trpc/index.d.ts

@@ -4,3 +4,4 @@ export { createFleetUpdateConfigRouter } from "./fleet-update-config-router.js";
 export { adminProcedure, createCallerFactory, orgAdminProcedure, orgMemberProcedure, protectedProcedure, publicProcedure, router, setTrpcOrgMemberRepo, type TRPCContext, tenantProcedure, } from "./init.js";
 export { createNotificationTemplateRouter } from "./notification-template-router.js";
 export { createOrgRemovePaymentMethodRouter, type OrgRemovePaymentMethodDeps, } from "./org-remove-payment-method-router.js";
+export { createProductConfigRouter } from "./product-config-router.js";

package/dist/trpc/index.js

@@ -4,3 +4,4 @@ export { createFleetUpdateConfigRouter } from "./fleet-update-config-router.js";
 export { adminProcedure, createCallerFactory, orgAdminProcedure, orgMemberProcedure, protectedProcedure, publicProcedure, router, setTrpcOrgMemberRepo, tenantProcedure, } from "./init.js";
 export { createNotificationTemplateRouter } from "./notification-template-router.js";
 export { createOrgRemovePaymentMethodRouter, } from "./org-remove-payment-method-router.js";
+export { createProductConfigRouter } from "./product-config-router.js";

package/dist/trpc/product-config-router.d.ts

@@ -0,0 +1,117 @@
+import type { ProductConfig } from "../product-config/repository-types.js";
+import type { ProductConfigService } from "../product-config/service.js";
+export declare function createProductConfigRouter(getService: () => ProductConfigService, productSlug: string): import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("./init.js").TRPCContext;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: false;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    getBrandConfig: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../product-config/repository-types.js").ProductBrandConfig | null;
+        meta: object;
+    }>;
+    getNavItems: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            label: string;
+            href: string;
+        }[];
+        meta: object;
+    }>;
+    admin: import("@trpc/server").TRPCBuiltRouter<{
+        ctx: import("./init.js").TRPCContext;
+        meta: object;
+        errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+        transformer: false;
+    }, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+        get: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: ProductConfig | null;
+            meta: object;
+        }>;
+        listAll: import("@trpc/server").TRPCQueryProcedure<{
+            input: void;
+            output: ProductConfig[];
+            meta: object;
+        }>;
+        updateBrand: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                brandName?: string | undefined;
+                productName?: string | undefined;
+                tagline?: string | undefined;
+                domain?: string | undefined;
+                appDomain?: string | undefined;
+                cookieDomain?: string | undefined;
+                companyLegal?: string | undefined;
+                priceLabel?: string | undefined;
+                defaultImage?: string | undefined;
+                emailSupport?: string | undefined;
+                emailPrivacy?: string | undefined;
+                emailLegal?: string | undefined;
+                fromEmail?: string | undefined;
+                homePath?: string | undefined;
+                storagePrefix?: string | undefined;
+            };
+            output: void;
+            meta: object;
+        }>;
+        updateNavItems: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                label: string;
+                href: string;
+                sortOrder: number;
+                icon?: string | undefined;
+                requiresRole?: string | undefined;
+                enabled?: boolean | undefined;
+            }[];
+            output: void;
+            meta: object;
+        }>;
+        updateFeatures: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                chatEnabled?: boolean | undefined;
+                onboardingEnabled?: boolean | undefined;
+                onboardingDefaultModel?: string | undefined;
+                onboardingSystemPrompt?: string | undefined;
+                onboardingMaxCredits?: number | undefined;
+                onboardingWelcomeMsg?: string | undefined;
+                sharedModuleBilling?: boolean | undefined;
+                sharedModuleMonitoring?: boolean | undefined;
+                sharedModuleAnalytics?: boolean | undefined;
+            };
+            output: void;
+            meta: object;
+        }>;
+        updateFleet: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                containerImage?: string | undefined;
+                containerPort?: number | undefined;
+                lifecycle?: "managed" | "ephemeral" | undefined;
+                billingModel?: "monthly" | "per_use" | "none" | undefined;
+                maxInstances?: number | undefined;
+                imageAllowlist?: string[] | undefined;
+                dockerNetwork?: string | undefined;
+                placementStrategy?: string | undefined;
+                fleetDataDir?: string | undefined;
+            };
+            output: void;
+            meta: object;
+        }>;
+        updateBilling: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                stripePublishableKey?: string | undefined;
+                stripeSecretKey?: string | undefined;
+                stripeWebhookSecret?: string | undefined;
+                creditPrices?: Record<string, number> | undefined;
+                affiliateBaseUrl?: string | undefined;
+                affiliateMatchRate?: number | undefined;
+                affiliateMaxCap?: number | undefined;
+                dividendRate?: number | undefined;
+                marginConfig?: unknown;
+            };
+            output: void;
+            meta: object;
+        }>;
+    }>>;
+}>>;

package/dist/trpc/product-config-router.js

@@ -0,0 +1,137 @@
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import { adminProcedure, publicProcedure, router } from "./init.js";
+/** Mask Stripe secrets in admin responses — never send raw keys over the wire. */
+function redactSecrets(config) {
+    if (!config.billing)
+        return config;
+    return {
+        ...config,
+        billing: {
+            ...config.billing,
+            stripeSecretKey: config.billing.stripeSecretKey ? "sk_...redacted" : null,
+            stripeWebhookSecret: config.billing.stripeWebhookSecret ? "whsec_...redacted" : null,
+        },
+    };
+}
+export function createProductConfigRouter(getService, productSlug) {
+    /** Resolve product id, throwing NOT_FOUND if the product doesn't exist. */
+    async function resolveProductId() {
+        const config = await getService().getBySlug(productSlug);
+        if (!config) {
+            throw new TRPCError({ code: "NOT_FOUND", message: `Product not found: ${productSlug}` });
+        }
+        return config.product.id;
+    }
+    return router({
+        // -----------------------------------------------------------------------
+        // Public endpoints
+        // -----------------------------------------------------------------------
+        getBrandConfig: publicProcedure.query(async () => {
+            return getService().getBrandConfig(productSlug);
+        }),
+        getNavItems: publicProcedure.query(async () => {
+            const config = await getService().getBySlug(productSlug);
+            if (!config)
+                return [];
+            return config.navItems.filter((n) => n.enabled).map((n) => ({ label: n.label, href: n.href }));
+        }),
+        // -----------------------------------------------------------------------
+        // Admin endpoints
+        // -----------------------------------------------------------------------
+        admin: router({
+            get: adminProcedure.query(async () => {
+                const config = await getService().getBySlug(productSlug);
+                if (!config)
+                    return null;
+                return redactSecrets(config);
+            }),
+            listAll: adminProcedure.query(async () => {
+                const configs = await getService().listAll();
+                return configs.map(redactSecrets);
+            }),
+            updateBrand: adminProcedure
+                .input(z.object({
+                brandName: z.string().min(1).optional(),
+                productName: z.string().min(1).optional(),
+                tagline: z.string().optional(),
+                domain: z.string().min(1).optional(),
+                appDomain: z.string().min(1).optional(),
+                cookieDomain: z.string().optional(),
+                companyLegal: z.string().optional(),
+                priceLabel: z.string().optional(),
+                defaultImage: z.string().optional(),
+                emailSupport: z.string().optional(),
+                emailPrivacy: z.string().optional(),
+                emailLegal: z.string().optional(),
+                fromEmail: z.string().optional(),
+                homePath: z.string().optional(),
+                storagePrefix: z.string().min(1).optional(),
+            }))
+                .mutation(async ({ input }) => {
+                await getService().upsertProduct(productSlug, input);
+            }),
+            updateNavItems: adminProcedure
+                .input(z.array(z.object({
+                label: z.string().min(1),
+                href: z.string().min(1),
+                icon: z.string().optional(),
+                sortOrder: z.number().int().min(0),
+                requiresRole: z.string().optional(),
+                enabled: z.boolean().optional(),
+            })))
+                .mutation(async ({ input }) => {
+                const productId = await resolveProductId();
+                await getService().replaceNavItems(productSlug, productId, input);
+            }),
+            updateFeatures: adminProcedure
+                .input(z.object({
+                chatEnabled: z.boolean().optional(),
+                onboardingEnabled: z.boolean().optional(),
+                onboardingDefaultModel: z.string().optional(),
+                onboardingSystemPrompt: z.string().optional(),
+                onboardingMaxCredits: z.number().int().min(0).optional(),
+                onboardingWelcomeMsg: z.string().optional(),
+                sharedModuleBilling: z.boolean().optional(),
+                sharedModuleMonitoring: z.boolean().optional(),
+                sharedModuleAnalytics: z.boolean().optional(),
+            }))
+                .mutation(async ({ input }) => {
+                const productId = await resolveProductId();
+                await getService().upsertFeatures(productSlug, productId, input);
+            }),
+            updateFleet: adminProcedure
+                .input(z.object({
+                containerImage: z.string().optional(),
+                containerPort: z.number().int().optional(),
+                lifecycle: z.enum(["managed", "ephemeral"]).optional(),
+                billingModel: z.enum(["monthly", "per_use", "none"]).optional(),
+                maxInstances: z.number().int().min(1).optional(),
+                imageAllowlist: z.array(z.string()).optional(),
+                dockerNetwork: z.string().optional(),
+                placementStrategy: z.string().optional(),
+                fleetDataDir: z.string().optional(),
+            }))
+                .mutation(async ({ input }) => {
+                const productId = await resolveProductId();
+                await getService().upsertFleetConfig(productSlug, productId, input);
+            }),
+            updateBilling: adminProcedure
+                .input(z.object({
+                stripePublishableKey: z.string().optional(),
+                stripeSecretKey: z.string().optional(),
+                stripeWebhookSecret: z.string().optional(),
+                creditPrices: z.record(z.string(), z.number()).optional(),
+                affiliateBaseUrl: z.string().optional(),
+                affiliateMatchRate: z.number().min(0).optional(),
+                affiliateMaxCap: z.number().int().min(0).optional(),
+                dividendRate: z.number().min(0).optional(),
+                marginConfig: z.unknown().optional(),
+            }))
+                .mutation(async ({ input }) => {
+                const productId = await resolveProductId();
+                await getService().upsertBillingConfig(productSlug, productId, input);
+            }),
+        }),
+    });
+}