@wopr-network/platform-core 1.58.0 → 1.59.0

package/src/product-config/service.ts

@@ -0,0 +1,105 @@
+import type {
+  IProductConfigRepository,
+  NavItemInput,
+  Product,
+  ProductBillingConfig,
+  ProductBrandConfig,
+  ProductBrandUpdate,
+  ProductConfig,
+  ProductFeatures,
+  ProductFleetConfig,
+} from "./repository-types.js";
+import { toBrandConfig } from "./repository-types.js";
+
+interface CacheEntry {
+  config: ProductConfig;
+  expiresAt: number;
+}
+
+/**
+ * Single point of access for product configuration.
+ *
+ * Wraps IProductConfigRepository with an in-memory cache.
+ * All mutations automatically invalidate the cache — no caller
+ * needs to remember to invalidate. This is the ONLY public
+ * interface to product config; consumers never touch the repo directly.
+ */
+export class ProductConfigService {
+  private cache = new Map<string, CacheEntry>();
+  private ttlMs: number;
+
+  constructor(
+    private repo: IProductConfigRepository,
+    opts: { ttlMs?: number } = {},
+  ) {
+    this.ttlMs = opts.ttlMs ?? 60_000;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Reads (cached)
+  // ---------------------------------------------------------------------------
+
+  async getBySlug(slug: string): Promise<ProductConfig | null> {
+    const entry = this.cache.get(slug);
+    if (entry && Date.now() < entry.expiresAt) {
+      return entry.config;
+    }
+    const config = await this.repo.getBySlug(slug);
+    if (config) {
+      this.cache.set(slug, { config, expiresAt: Date.now() + this.ttlMs });
+    }
+    return config;
+  }
+
+  async getBrandConfig(slug: string): Promise<ProductBrandConfig | null> {
+    const config = await this.getBySlug(slug);
+    if (!config) return null;
+    return toBrandConfig(config);
+  }
+
+  async listAll(): Promise<ProductConfig[]> {
+    return this.repo.listAll();
+  }
+
+  // ---------------------------------------------------------------------------
+  // Writes (auto-invalidate)
+  // ---------------------------------------------------------------------------
+
+  async upsertProduct(slug: string, data: ProductBrandUpdate): Promise<Product> {
+    const result = await this.repo.upsertProduct(slug, data);
+    this.invalidate(slug);
+    return result;
+  }
+
+  async replaceNavItems(slug: string, productId: string, items: NavItemInput[]): Promise<void> {
+    await this.repo.replaceNavItems(productId, items);
+    this.invalidate(slug);
+  }
+
+  async upsertFeatures(slug: string, productId: string, data: Partial<ProductFeatures>): Promise<void> {
+    await this.repo.upsertFeatures(productId, data);
+    this.invalidate(slug);
+  }
+
+  async upsertFleetConfig(slug: string, productId: string, data: Partial<ProductFleetConfig>): Promise<void> {
+    await this.repo.upsertFleetConfig(productId, data);
+    this.invalidate(slug);
+  }
+
+  async upsertBillingConfig(slug: string, productId: string, data: Partial<ProductBillingConfig>): Promise<void> {
+    await this.repo.upsertBillingConfig(productId, data);
+    this.invalidate(slug);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Cache management
+  // ---------------------------------------------------------------------------
+
+  invalidate(slug: string): void {
+    this.cache.delete(slug);
+  }
+
+  invalidateAll(): void {
+    this.cache.clear();
+  }
+}

package/src/trpc/index.ts

@@ -18,3 +18,4 @@ export {
   createOrgRemovePaymentMethodRouter,
   type OrgRemovePaymentMethodDeps,
 } from "./org-remove-payment-method-router.js";
+export { createProductConfigRouter } from "./product-config-router.js";

package/src/trpc/product-config-router.ts

@@ -0,0 +1,161 @@
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+import type { ProductConfig } from "../product-config/repository-types.js";
+import type { ProductConfigService } from "../product-config/service.js";
+import { adminProcedure, publicProcedure, router } from "./init.js";
+
+/** Mask Stripe secrets in admin responses — never send raw keys over the wire. */
+function redactSecrets(config: ProductConfig): ProductConfig {
+  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: () => ProductConfigService, productSlug: string) {
+  /** Resolve product id, throwing NOT_FOUND if the product doesn't exist. */
+  async function resolveProductId(): Promise<string> {
+    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);
+        }),
+    }),
+  });
+}