@wopr-network/platform-core 1.58.1 → 1.60.0

package/src/db/schema/product-config.ts

@@ -0,0 +1,56 @@
+import { boolean, integer, jsonb, numeric, pgEnum, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+
+import { products } from "./products.js";
+
+export const fleetLifecycleEnum = pgEnum("fleet_lifecycle", ["managed", "ephemeral"]);
+export const fleetBillingModelEnum = pgEnum("fleet_billing_model", ["monthly", "per_use", "none"]);
+
+export const productFeatures = pgTable("product_features", {
+  productId: uuid("product_id")
+    .primaryKey()
+    .references(() => products.id, { onDelete: "cascade" }),
+  chatEnabled: boolean("chat_enabled").notNull().default(true),
+  onboardingEnabled: boolean("onboarding_enabled").notNull().default(true),
+  onboardingDefaultModel: text("onboarding_default_model"),
+  onboardingSystemPrompt: text("onboarding_system_prompt"),
+  onboardingMaxCredits: integer("onboarding_max_credits").notNull().default(100),
+  onboardingWelcomeMsg: text("onboarding_welcome_msg"),
+  sharedModuleBilling: boolean("shared_module_billing").notNull().default(true),
+  sharedModuleMonitoring: boolean("shared_module_monitoring").notNull().default(true),
+  sharedModuleAnalytics: boolean("shared_module_analytics").notNull().default(true),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const productFleetConfig = pgTable("product_fleet_config", {
+  productId: uuid("product_id")
+    .primaryKey()
+    .references(() => products.id, { onDelete: "cascade" }),
+  containerImage: text("container_image").notNull(),
+  containerPort: integer("container_port").notNull().default(3100),
+  lifecycle: fleetLifecycleEnum("lifecycle").notNull().default("managed"),
+  billingModel: fleetBillingModelEnum("billing_model").notNull().default("monthly"),
+  maxInstances: integer("max_instances").notNull().default(5),
+  imageAllowlist: text("image_allowlist").array(),
+  dockerNetwork: text("docker_network").notNull().default(""),
+  placementStrategy: text("placement_strategy").notNull().default("least-loaded"),
+  fleetDataDir: text("fleet_data_dir").notNull().default("/data/fleet"),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});
+
+export const productBillingConfig = pgTable("product_billing_config", {
+  productId: uuid("product_id")
+    .primaryKey()
+    .references(() => products.id, { onDelete: "cascade" }),
+  stripePublishableKey: text("stripe_publishable_key"),
+  /** Encrypted via credential vault (CRYPTO_SERVICE_KEY) before storage. */
+  stripeSecretKey: text("stripe_secret_key"),
+  /** Encrypted via credential vault (CRYPTO_SERVICE_KEY) before storage. */
+  stripeWebhookSecret: text("stripe_webhook_secret"),
+  creditPrices: jsonb("credit_prices").notNull().default({}),
+  affiliateBaseUrl: text("affiliate_base_url"),
+  affiliateMatchRate: numeric("affiliate_match_rate").notNull().default("1.0"),
+  affiliateMaxCap: integer("affiliate_max_cap").notNull().default(20000),
+  dividendRate: numeric("dividend_rate").notNull().default("1.0"),
+  marginConfig: jsonb("margin_config"),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});

package/src/db/schema/products.ts

@@ -0,0 +1,58 @@
+import { boolean, index, integer, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+
+export const products = pgTable(
+  "products",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    slug: text("slug").notNull(),
+    brandName: text("brand_name").notNull(),
+    productName: text("product_name").notNull(),
+    tagline: text("tagline").notNull().default(""),
+    domain: text("domain").notNull(),
+    appDomain: text("app_domain").notNull(),
+    cookieDomain: text("cookie_domain").notNull(),
+    companyLegal: text("company_legal").notNull().default(""),
+    priceLabel: text("price_label").notNull().default(""),
+    defaultImage: text("default_image").notNull().default(""),
+    emailSupport: text("email_support").notNull().default(""),
+    emailPrivacy: text("email_privacy").notNull().default(""),
+    emailLegal: text("email_legal").notNull().default(""),
+    fromEmail: text("from_email").notNull().default(""),
+    homePath: text("home_path").notNull().default("/marketplace"),
+    storagePrefix: text("storage_prefix").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [uniqueIndex("products_slug_idx").on(t.slug)],
+);
+
+export const productNavItems = pgTable(
+  "product_nav_items",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    productId: uuid("product_id")
+      .notNull()
+      .references(() => products.id, { onDelete: "cascade" }),
+    label: text("label").notNull(),
+    href: text("href").notNull(),
+    icon: text("icon"),
+    sortOrder: integer("sort_order").notNull(),
+    requiresRole: text("requires_role"),
+    enabled: boolean("enabled").notNull().default(true),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+  },
+  (t) => [index("product_nav_items_product_sort_idx").on(t.productId, t.sortOrder)],
+);
+
+export const productDomains = pgTable(
+  "product_domains",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    productId: uuid("product_id")
+      .notNull()
+      .references(() => products.id, { onDelete: "cascade" }),
+    host: text("host").notNull(),
+    role: text("role").notNull().default("canonical"),
+  },
+  (t) => [uniqueIndex("product_domains_product_host_idx").on(t.productId, t.host)],
+);

package/src/product-config/boot.ts

@@ -0,0 +1,57 @@
+import type { DrizzleDb } from "../db/index.js";
+import { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+import type { ProductConfig } from "./repository-types.js";
+import { deriveCorsOrigins } from "./repository-types.js";
+import { ProductConfigService } from "./service.js";
+
+export interface PlatformBootResult {
+  /** The product config service — single point of access for config reads/writes. */
+  service: ProductConfigService;
+  /** The resolved product config (cached). */
+  config: ProductConfig;
+  /** CORS origins derived from product domains + optional dev origins. */
+  corsOrigins: string[];
+}
+
+export interface PlatformBootOptions {
+  /** Product slug (e.g. "paperclip", "wopr", "holyship", "nemoclaw"). */
+  slug: string;
+  /** Drizzle database instance. */
+  db: DrizzleDb;
+  /** Additional CORS origins for local dev (from DEV_ORIGINS env var). */
+  devOrigins?: string[];
+}
+
+/**
+ * Bootstrap product configuration from DB.
+ *
+ * Call once at startup, after DB + migrations, before route registration.
+ * Returns the service (for tRPC router wiring) and the resolved config
+ * (for CORS, email, fleet, auth initialization).
+ *
+ * This replaces: BRAND_NAME, PLATFORM_DOMAIN, UI_ORIGIN, FROM_EMAIL,
+ * SUPPORT_EMAIL, COOKIE_DOMAIN, APP_BASE_URL, and all other product-
+ * specific env vars that platform-core modules previously read from
+ * process.env.
+ *
+ * Product backends still own their specific wiring (crypto watchers,
+ * fleet updaters, notification pipelines). platformBoot handles the
+ * config-driven parts that are identical across products.
+ */
+export async function platformBoot(opts: PlatformBootOptions): Promise<PlatformBootResult> {
+  const { slug, db, devOrigins = [] } = opts;
+
+  const repo = new DrizzleProductConfigRepository(db);
+  const service = new ProductConfigService(repo);
+
+  const config = await service.getBySlug(slug);
+  if (!config) {
+    throw new Error(
+      `Product "${slug}" not found in database. Run the seed script: DATABASE_URL=... npx tsx scripts/seed-products.ts`,
+    );
+  }
+
+  const corsOrigins = [...deriveCorsOrigins(config.product, config.domains), ...devOrigins];
+
+  return { service, config, corsOrigins };
+}

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

@@ -0,0 +1,132 @@
+import type { PGlite } from "@electric-sql/pglite";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import type { DrizzleDb } from "../db/index.js";
+import { products } from "../db/schema/products.js";
+import { createTestDb } from "../test/db.js";
+import { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+
+const PRODUCT_SEED = {
+  slug: "test-product",
+  brandName: "Test Brand",
+  productName: "Test Product",
+  domain: "test.example.com",
+  appDomain: "app.test.example.com",
+  cookieDomain: ".test.example.com",
+  storagePrefix: "test",
+};
+
+describe("DrizzleProductConfigRepository", () => {
+  let db: DrizzleDb;
+  let pool: PGlite;
+  let repo: DrizzleProductConfigRepository;
+
+  beforeAll(async () => {
+    const result = await createTestDb();
+    db = result.db as unknown as DrizzleDb;
+    pool = result.pool;
+    repo = new DrizzleProductConfigRepository(db);
+  });
+
+  afterAll(async () => {
+    await pool.close();
+  });
+
+  it("getBySlug returns null for unknown slug", async () => {
+    const result = await repo.getBySlug("no-such-slug");
+    expect(result).toBeNull();
+  });
+
+  it("getBySlug returns full config for seeded product with empty related tables", async () => {
+    await db.insert(products).values(PRODUCT_SEED);
+
+    const config = await repo.getBySlug("test-product");
+
+    expect(config).not.toBeNull();
+    expect(config?.product.slug).toBe("test-product");
+    expect(config?.product.brandName).toBe("Test Brand");
+    expect(config?.navItems).toHaveLength(0);
+    expect(config?.domains).toHaveLength(0);
+    expect(config?.features).toBeNull();
+    expect(config?.fleet).toBeNull();
+    expect(config?.billing).toBeNull();
+  });
+
+  it("replaceNavItems then getBySlug returns sorted nav items", async () => {
+    const config = await repo.getBySlug("test-product");
+    if (!config) throw new Error("product not found");
+    const productId = config.product.id;
+
+    await repo.replaceNavItems(productId, [
+      { label: "Beta", href: "/beta", sortOrder: 2 },
+      { label: "Alpha", href: "/alpha", sortOrder: 1 },
+      { label: "Gamma", href: "/gamma", sortOrder: 3, requiresRole: "admin" },
+    ]);
+
+    const updated = await repo.getBySlug("test-product");
+    expect(updated?.navItems).toHaveLength(3);
+    expect(updated?.navItems[0].label).toBe("Alpha");
+    expect(updated?.navItems[1].label).toBe("Beta");
+    expect(updated?.navItems[2].label).toBe("Gamma");
+    expect(updated?.navItems[2].requiresRole).toBe("admin");
+  });
+
+  it("upsertFeatures then getBySlug returns features", async () => {
+    const config = await repo.getBySlug("test-product");
+    if (!config) throw new Error("product not found");
+    const productId = config.product.id;
+
+    await repo.upsertFeatures(productId, {
+      chatEnabled: false,
+      onboardingEnabled: true,
+      onboardingDefaultModel: "gpt-4o",
+      onboardingMaxCredits: 50,
+    });
+
+    const updated = await repo.getBySlug("test-product");
+    expect(updated?.features).not.toBeNull();
+    expect(updated?.features?.chatEnabled).toBe(false);
+    expect(updated?.features?.onboardingDefaultModel).toBe("gpt-4o");
+    expect(updated?.features?.onboardingMaxCredits).toBe(50);
+  });
+
+  it("upsertFleetConfig with lifecycle ephemeral and billingModel none", async () => {
+    const config = await repo.getBySlug("test-product");
+    if (!config) throw new Error("product not found");
+    const productId = config.product.id;
+
+    await repo.upsertFleetConfig(productId, {
+      containerImage: "ghcr.io/example/app:latest",
+      lifecycle: "ephemeral",
+      billingModel: "none",
+      containerPort: 8080,
+      maxInstances: 10,
+    });
+
+    const updated = await repo.getBySlug("test-product");
+    expect(updated?.fleet).not.toBeNull();
+    expect(updated?.fleet?.containerImage).toBe("ghcr.io/example/app:latest");
+    expect(updated?.fleet?.lifecycle).toBe("ephemeral");
+    expect(updated?.fleet?.billingModel).toBe("none");
+    expect(updated?.fleet?.containerPort).toBe(8080);
+    expect(updated?.fleet?.maxInstances).toBe(10);
+  });
+
+  it("listAll returns all products", async () => {
+    // Insert a second product
+    await db.insert(products).values({
+      slug: "second-product",
+      brandName: "Second Brand",
+      productName: "Second Product",
+      domain: "second.example.com",
+      appDomain: "app.second.example.com",
+      cookieDomain: ".second.example.com",
+      storagePrefix: "second",
+    });
+
+    const all = await repo.listAll();
+    const slugs = all.map((c) => c.product.slug);
+    expect(slugs).toContain("test-product");
+    expect(slugs).toContain("second-product");
+    expect(all.length).toBeGreaterThanOrEqual(2);
+  });
+});

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;
+}