@wopr-network/platform-core 1.58.0 → 1.59.0

package/src/product-config/drizzle-product-config-repository.ts

@@ -0,0 +1,229 @@
+import { asc, eq } from "drizzle-orm";
+import type { DrizzleDb } from "../db/index.js";
+import { productBillingConfig, productFeatures, productFleetConfig } from "../db/schema/product-config.js";
+import { productDomains, productNavItems, products } from "../db/schema/products.js";
+import type {
+  IProductConfigRepository,
+  NavItemInput,
+  Product,
+  ProductBillingConfig as ProductBillingConfigType,
+  ProductBrandUpdate,
+  ProductConfig,
+  ProductDomain,
+  ProductFeatures as ProductFeaturesType,
+  ProductFleetConfig as ProductFleetConfigType,
+  ProductNavItem,
+} from "./repository-types.js";
+
+export class DrizzleProductConfigRepository implements IProductConfigRepository {
+  constructor(private db: DrizzleDb) {}
+
+  async getBySlug(slug: string): Promise<ProductConfig | null> {
+    const [product] = await this.db.select().from(products).where(eq(products.slug, slug)).limit(1);
+
+    if (!product) return null;
+
+    const [navItems, domains, featuresRows, fleetRows, billingRows] = await Promise.all([
+      this.db
+        .select()
+        .from(productNavItems)
+        .where(eq(productNavItems.productId, product.id))
+        .orderBy(asc(productNavItems.sortOrder)),
+      this.db.select().from(productDomains).where(eq(productDomains.productId, product.id)),
+      this.db.select().from(productFeatures).where(eq(productFeatures.productId, product.id)).limit(1),
+      this.db.select().from(productFleetConfig).where(eq(productFleetConfig.productId, product.id)).limit(1),
+      this.db.select().from(productBillingConfig).where(eq(productBillingConfig.productId, product.id)).limit(1),
+    ]);
+
+    return {
+      product: this.mapProduct(product),
+      navItems: navItems.map((n) => this.mapNavItem(n)),
+      domains: domains.map((d) => this.mapDomain(d)),
+      features: featuresRows[0] ? this.mapFeatures(featuresRows[0]) : null,
+      fleet: fleetRows[0] ? this.mapFleet(fleetRows[0]) : null,
+      billing: billingRows[0] ? this.mapBilling(billingRows[0]) : null,
+    };
+  }
+
+  async listAll(): Promise<ProductConfig[]> {
+    const allProducts = await this.db.select().from(products);
+    const configs = await Promise.all(allProducts.map((p) => this.getBySlug(p.slug)));
+    return configs.filter((c): c is ProductConfig => c !== null);
+  }
+
+  async upsertProduct(slug: string, data: ProductBrandUpdate): Promise<Product> {
+    const base = {
+      slug,
+      storagePrefix: slug,
+      domain: "",
+      appDomain: "",
+      cookieDomain: "",
+      brandName: "",
+      productName: "",
+    };
+    const [result] = await this.db
+      .insert(products)
+      .values({ ...base, ...data })
+      .onConflictDoUpdate({
+        target: products.slug,
+        set: { ...(data as Record<string, unknown>), updatedAt: new Date() },
+      })
+      .returning();
+    return this.mapProduct(result);
+  }
+
+  async replaceNavItems(productId: string, items: NavItemInput[]): Promise<void> {
+    await this.db.transaction(async (tx) => {
+      await tx.delete(productNavItems).where(eq(productNavItems.productId, productId));
+      if (items.length > 0) {
+        await tx.insert(productNavItems).values(
+          items.map((item) => ({
+            productId,
+            label: item.label,
+            href: item.href,
+            icon: item.icon ?? null,
+            sortOrder: item.sortOrder,
+            requiresRole: item.requiresRole ?? null,
+            enabled: item.enabled !== false,
+          })),
+        );
+      }
+    });
+  }
+
+  async upsertFeatures(productId: string, data: Partial<ProductFeaturesType>): Promise<void> {
+    const { productId: _, ...rest } = data as Record<string, unknown>;
+    await this.db
+      .insert(productFeatures)
+      // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+      .values({ productId, ...rest } as any)
+      .onConflictDoUpdate({
+        target: productFeatures.productId,
+        // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+        set: { ...rest, updatedAt: new Date() } as any,
+      });
+  }
+
+  async upsertFleetConfig(productId: string, data: Partial<ProductFleetConfigType>): Promise<void> {
+    const { productId: _, ...rest } = data as Record<string, unknown>;
+    await this.db
+      .insert(productFleetConfig)
+      // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+      .values({ productId, containerImage: "", ...rest } as any)
+      .onConflictDoUpdate({
+        target: productFleetConfig.productId,
+        // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+        set: { ...rest, updatedAt: new Date() } as any,
+      });
+  }
+
+  async upsertBillingConfig(productId: string, data: Partial<ProductBillingConfigType>): Promise<void> {
+    // TODO: stripeSecretKey and stripeWebhookSecret must be encrypted via the credential vault
+    // (CRYPTO_SERVICE_KEY) before reaching this method. The schema stores encrypted ciphertext.
+    const { productId: _, ...rest } = data as Record<string, unknown>;
+    await this.db
+      .insert(productBillingConfig)
+      // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+      .values({ productId, ...rest } as any)
+      .onConflictDoUpdate({
+        target: productBillingConfig.productId,
+        // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+        set: { ...rest, updatedAt: new Date() } as any,
+      });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Mappers
+  // ---------------------------------------------------------------------------
+
+  private mapProduct(row: typeof products.$inferSelect): Product {
+    return {
+      id: row.id,
+      slug: row.slug,
+      brandName: row.brandName,
+      productName: row.productName,
+      tagline: row.tagline,
+      domain: row.domain,
+      appDomain: row.appDomain,
+      cookieDomain: row.cookieDomain,
+      companyLegal: row.companyLegal,
+      priceLabel: row.priceLabel,
+      defaultImage: row.defaultImage,
+      emailSupport: row.emailSupport,
+      emailPrivacy: row.emailPrivacy,
+      emailLegal: row.emailLegal,
+      fromEmail: row.fromEmail,
+      homePath: row.homePath,
+      storagePrefix: row.storagePrefix,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  private mapNavItem(row: typeof productNavItems.$inferSelect): ProductNavItem {
+    return {
+      id: row.id,
+      productId: row.productId,
+      label: row.label,
+      href: row.href,
+      icon: row.icon ?? null,
+      sortOrder: row.sortOrder,
+      requiresRole: row.requiresRole ?? null,
+      enabled: row.enabled,
+    };
+  }
+
+  private mapDomain(row: typeof productDomains.$inferSelect): ProductDomain {
+    return {
+      id: row.id,
+      productId: row.productId,
+      host: row.host,
+      role: row.role as "canonical" | "redirect",
+    };
+  }
+
+  private mapFeatures(row: typeof productFeatures.$inferSelect): ProductFeaturesType {
+    return {
+      productId: row.productId,
+      chatEnabled: row.chatEnabled,
+      onboardingEnabled: row.onboardingEnabled,
+      onboardingDefaultModel: row.onboardingDefaultModel ?? null,
+      onboardingSystemPrompt: row.onboardingSystemPrompt ?? null,
+      onboardingMaxCredits: row.onboardingMaxCredits,
+      onboardingWelcomeMsg: row.onboardingWelcomeMsg ?? null,
+      sharedModuleBilling: row.sharedModuleBilling,
+      sharedModuleMonitoring: row.sharedModuleMonitoring,
+      sharedModuleAnalytics: row.sharedModuleAnalytics,
+    };
+  }
+
+  private mapFleet(row: typeof productFleetConfig.$inferSelect): ProductFleetConfigType {
+    return {
+      productId: row.productId,
+      containerImage: row.containerImage,
+      containerPort: row.containerPort,
+      lifecycle: row.lifecycle as ProductFleetConfigType["lifecycle"],
+      billingModel: row.billingModel as ProductFleetConfigType["billingModel"],
+      maxInstances: row.maxInstances,
+      imageAllowlist: row.imageAllowlist ?? null,
+      dockerNetwork: row.dockerNetwork,
+      placementStrategy: row.placementStrategy,
+      fleetDataDir: row.fleetDataDir,
+    };
+  }
+
+  private mapBilling(row: typeof productBillingConfig.$inferSelect): ProductBillingConfigType {
+    return {
+      productId: row.productId,
+      stripePublishableKey: row.stripePublishableKey ?? null,
+      stripeSecretKey: row.stripeSecretKey ?? null,
+      stripeWebhookSecret: row.stripeWebhookSecret ?? null,
+      creditPrices: (row.creditPrices ?? {}) as Record<string, number>,
+      affiliateBaseUrl: row.affiliateBaseUrl ?? null,
+      affiliateMatchRate: Number(row.affiliateMatchRate),
+      affiliateMaxCap: row.affiliateMaxCap,
+      dividendRate: Number(row.dividendRate),
+      marginConfig: row.marginConfig ?? null,
+    };
+  }
+}

package/src/product-config/index.ts

@@ -0,0 +1,62 @@
+import type { DrizzleDb } from "../db/index.js";
+import type { PlatformBootOptions, PlatformBootResult } from "./boot.js";
+import { platformBoot as rawPlatformBoot } from "./boot.js";
+import { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+import type { IProductConfigRepository } from "./repository-types.js";
+import { ProductConfigService } from "./service.js";
+
+export type { PlatformBootOptions, PlatformBootResult } from "./boot.js";
+
+/**
+ * Bootstrap product config from DB and register the service globally.
+ * Wraps the raw boot to ensure getProductConfigService() works after calling this.
+ */
+export async function platformBoot(opts: PlatformBootOptions): Promise<PlatformBootResult> {
+  const result = await rawPlatformBoot(opts);
+  _service = result.service;
+  return result;
+}
+export { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+// Re-exports for consumers
+export type {
+  FleetBillingModel,
+  FleetLifecycle,
+  IProductConfigRepository,
+  NavItemInput,
+  Product,
+  ProductBillingConfig,
+  ProductBrandConfig,
+  ProductBrandUpdate,
+  ProductConfig,
+  ProductDomain,
+  ProductFeatures,
+  ProductFleetConfig,
+  ProductNavItem,
+} from "./repository-types.js";
+export { deriveCorsOrigins, toBrandConfig } from "./repository-types.js";
+export { ProductConfigService } from "./service.js";
+
+let _service: ProductConfigService | null = null;
+
+/** Initialize the product config system. Call once at startup. */
+export function initProductConfig(db: DrizzleDb): ProductConfigService {
+  const repo = new DrizzleProductConfigRepository(db);
+  _service = new ProductConfigService(repo);
+  return _service;
+}
+
+/** Initialize with a custom repository (for testing). */
+export function initProductConfigWithRepo(repo: IProductConfigRepository): ProductConfigService {
+  _service = new ProductConfigService(repo);
+  return _service;
+}
+
+/**
+ * Get the product config service.
+ * This is the ONLY way to access product config — reads are cached,
+ * writes auto-invalidate the cache.
+ */
+export function getProductConfigService(): ProductConfigService {
+  if (!_service) throw new Error("Product config not initialized. Call initProductConfig() first.");
+  return _service;
+}

package/src/product-config/repository-types.ts

@@ -0,0 +1,222 @@
+// src/product-config/repository-types.ts
+//
+// Plain TypeScript interfaces for product configuration domain.
+// No Drizzle types. These are the contract all consumers work against.
+
+// ---------------------------------------------------------------------------
+// Product
+// ---------------------------------------------------------------------------
+
+/** Plain domain object representing a product — mirrors `products` table. */
+export interface Product {
+  id: string;
+  slug: string;
+  brandName: string;
+  productName: string;
+  tagline: string;
+  domain: string;
+  appDomain: string;
+  cookieDomain: string;
+  companyLegal: string;
+  priceLabel: string;
+  defaultImage: string;
+  emailSupport: string;
+  emailPrivacy: string;
+  emailLegal: string;
+  fromEmail: string;
+  homePath: string;
+  storagePrefix: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+// ---------------------------------------------------------------------------
+// ProductNavItem
+// ---------------------------------------------------------------------------
+
+export interface ProductNavItem {
+  id: string;
+  productId: string;
+  label: string;
+  href: string;
+  icon: string | null;
+  sortOrder: number;
+  requiresRole: string | null;
+  enabled: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// ProductDomain
+// ---------------------------------------------------------------------------
+
+export interface ProductDomain {
+  id: string;
+  productId: string;
+  host: string;
+  role: "canonical" | "redirect";
+}
+
+// ---------------------------------------------------------------------------
+// ProductFeatures
+// ---------------------------------------------------------------------------
+
+export interface ProductFeatures {
+  productId: string;
+  chatEnabled: boolean;
+  onboardingEnabled: boolean;
+  onboardingDefaultModel: string | null;
+  onboardingSystemPrompt: string | null;
+  onboardingMaxCredits: number;
+  onboardingWelcomeMsg: string | null;
+  sharedModuleBilling: boolean;
+  sharedModuleMonitoring: boolean;
+  sharedModuleAnalytics: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// ProductFleetConfig
+// ---------------------------------------------------------------------------
+
+export type FleetLifecycle = "managed" | "ephemeral";
+export type FleetBillingModel = "monthly" | "per_use" | "none";
+
+export interface ProductFleetConfig {
+  productId: string;
+  containerImage: string;
+  containerPort: number;
+  lifecycle: FleetLifecycle;
+  billingModel: FleetBillingModel;
+  maxInstances: number;
+  imageAllowlist: string[] | null;
+  dockerNetwork: string;
+  placementStrategy: string;
+  fleetDataDir: string;
+}
+
+// ---------------------------------------------------------------------------
+// ProductBillingConfig
+// ---------------------------------------------------------------------------
+
+export interface ProductBillingConfig {
+  productId: string;
+  stripePublishableKey: string | null;
+  stripeSecretKey: string | null;
+  stripeWebhookSecret: string | null;
+  creditPrices: Record<string, number>;
+  affiliateBaseUrl: string | null;
+  affiliateMatchRate: number;
+  affiliateMaxCap: number;
+  dividendRate: number;
+  marginConfig: unknown;
+}
+
+// ---------------------------------------------------------------------------
+// Aggregates
+// ---------------------------------------------------------------------------
+
+/** Full product config resolved from all tables. */
+export interface ProductConfig {
+  product: Product;
+  navItems: ProductNavItem[];
+  domains: ProductDomain[];
+  features: ProductFeatures | null;
+  fleet: ProductFleetConfig | null;
+  billing: ProductBillingConfig | null;
+}
+
+/** Brand config shape served to UI (matches BrandConfig in platform-ui-core). */
+export interface ProductBrandConfig {
+  productName: string;
+  brandName: string;
+  domain: string;
+  appDomain: string;
+  tagline: string;
+  emails: { privacy: string; legal: string; support: string };
+  defaultImage: string;
+  storagePrefix: string;
+  companyLegalName: string;
+  price: string;
+  homePath: string;
+  chatEnabled: boolean;
+  navItems: Array<{ label: string; href: string }>;
+  domains?: Array<{ host: string; role: string }>;
+}
+
+// ---------------------------------------------------------------------------
+// Repository Interface
+// ---------------------------------------------------------------------------
+
+/** Upsert payload for product brand fields. */
+export type ProductBrandUpdate = Partial<Omit<Product, "id" | "slug" | "createdAt" | "updatedAt">>;
+
+/** Upsert payload for a nav item (no id — replaced in bulk). */
+export interface NavItemInput {
+  label: string;
+  href: string;
+  icon?: string;
+  sortOrder: number;
+  requiresRole?: string;
+  enabled?: boolean;
+}
+
+export interface IProductConfigRepository {
+  getBySlug(slug: string): Promise<ProductConfig | null>;
+  listAll(): Promise<ProductConfig[]>;
+  upsertProduct(slug: string, data: ProductBrandUpdate): Promise<Product>;
+  replaceNavItems(productId: string, items: NavItemInput[]): Promise<void>;
+  upsertFeatures(productId: string, data: Partial<ProductFeatures>): Promise<void>;
+  upsertFleetConfig(productId: string, data: Partial<ProductFleetConfig>): Promise<void>;
+  upsertBillingConfig(productId: string, data: Partial<ProductBillingConfig>): Promise<void>;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Derive CORS origins from product config. */
+/** Derive CORS origins — excludes redirect-only domains (they 301, never make requests). */
+export function deriveCorsOrigins(product: Product, domains: ProductDomain[]): string[] {
+  const origins = new Set<string>();
+  origins.add(`https://${product.domain}`);
+  origins.add(`https://${product.appDomain}`);
+  for (const d of domains) {
+    if (d.role !== "redirect") {
+      origins.add(`https://${d.host}`);
+    }
+  }
+  return [...origins];
+}
+
+/**
+ * Derive brand config for UI from full product config.
+ *
+ * @param config - Full product config.
+ * @param userRole - Optional role of the requesting user. When omitted (public/unauthenticated),
+ *   nav items that require a role are excluded from the result.
+ */
+export function toBrandConfig(config: ProductConfig, userRole?: string): ProductBrandConfig {
+  const { product, navItems, domains, features } = config;
+  return {
+    productName: product.productName,
+    brandName: product.brandName,
+    domain: product.domain,
+    appDomain: product.appDomain,
+    tagline: product.tagline,
+    emails: {
+      privacy: product.emailPrivacy,
+      legal: product.emailLegal,
+      support: product.emailSupport,
+    },
+    defaultImage: product.defaultImage,
+    storagePrefix: product.storagePrefix,
+    companyLegalName: product.companyLegal,
+    price: product.priceLabel,
+    homePath: product.homePath,
+    chatEnabled: features?.chatEnabled ?? true,
+    navItems: navItems
+      .filter((n) => n.enabled)
+      .filter((n) => !n.requiresRole || n.requiresRole === userRole)
+      .map((n) => ({ label: n.label, href: n.href })),
+    domains: domains.length > 0 ? domains.map((d) => ({ host: d.host, role: d.role })) : undefined,
+  };
+}

package/src/product-config/service.test.ts

@@ -0,0 +1,127 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { IProductConfigRepository, Product, ProductConfig } from "./repository-types.js";
+import { ProductConfigService } from "./service.js";
+
+function makeConfig(slug: string): ProductConfig {
+  const product: 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(): IProductConfigRepository {
+  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: ReturnType<typeof mockRepo>;
+  let service: ProductConfigService;
+
+  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 as ReturnType<typeof vi.fn>).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 as ReturnType<typeof vi.fn>).mockResolvedValue(null);
+    const brand = await service.getBrandConfig("missing");
+    expect(brand).toBeNull();
+  });
+});