@wopr-network/platform-core 1.58.0 → 1.59.0

package/dist/product-config/boot.js

@@ -0,0 +1,30 @@
+import { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+import { deriveCorsOrigins } from "./repository-types.js";
+import { ProductConfigService } from "./service.js";
+/**
+ * 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) {
+    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/dist/product-config/drizzle-product-config-repository.d.ts

@@ -0,0 +1,19 @@
+import type { DrizzleDb } from "../db/index.js";
+import type { IProductConfigRepository, NavItemInput, Product, ProductBillingConfig as ProductBillingConfigType, ProductBrandUpdate, ProductConfig, ProductFeatures as ProductFeaturesType, ProductFleetConfig as ProductFleetConfigType } from "./repository-types.js";
+export declare class DrizzleProductConfigRepository implements IProductConfigRepository {
+    private db;
+    constructor(db: DrizzleDb);
+    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<ProductFeaturesType>): Promise<void>;
+    upsertFleetConfig(productId: string, data: Partial<ProductFleetConfigType>): Promise<void>;
+    upsertBillingConfig(productId: string, data: Partial<ProductBillingConfigType>): Promise<void>;
+    private mapProduct;
+    private mapNavItem;
+    private mapDomain;
+    private mapFeatures;
+    private mapFleet;
+    private mapBilling;
+}

package/dist/product-config/drizzle-product-config-repository.js

@@ -0,0 +1,200 @@
+import { asc, eq } from "drizzle-orm";
+import { productBillingConfig, productFeatures, productFleetConfig } from "../db/schema/product-config.js";
+import { productDomains, productNavItems, products } from "../db/schema/products.js";
+export class DrizzleProductConfigRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getBySlug(slug) {
+        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() {
+        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 !== null);
+    }
+    async upsertProduct(slug, data) {
+        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, updatedAt: new Date() },
+        })
+            .returning();
+        return this.mapProduct(result);
+    }
+    async replaceNavItems(productId, items) {
+        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, data) {
+        const { productId: _, ...rest } = data;
+        await this.db
+            .insert(productFeatures)
+            // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+            .values({ productId, ...rest })
+            .onConflictDoUpdate({
+            target: productFeatures.productId,
+            // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+            set: { ...rest, updatedAt: new Date() },
+        });
+    }
+    async upsertFleetConfig(productId, data) {
+        const { productId: _, ...rest } = data;
+        await this.db
+            .insert(productFleetConfig)
+            // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+            .values({ productId, containerImage: "", ...rest })
+            .onConflictDoUpdate({
+            target: productFleetConfig.productId,
+            // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+            set: { ...rest, updatedAt: new Date() },
+        });
+    }
+    async upsertBillingConfig(productId, data) {
+        // 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;
+        await this.db
+            .insert(productBillingConfig)
+            // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+            .values({ productId, ...rest })
+            .onConflictDoUpdate({
+            target: productBillingConfig.productId,
+            // biome-ignore lint/suspicious/noExplicitAny: Drizzle partial upsert requires unknown spread
+            set: { ...rest, updatedAt: new Date() },
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Mappers
+    // ---------------------------------------------------------------------------
+    mapProduct(row) {
+        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,
+        };
+    }
+    mapNavItem(row) {
+        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,
+        };
+    }
+    mapDomain(row) {
+        return {
+            id: row.id,
+            productId: row.productId,
+            host: row.host,
+            role: row.role,
+        };
+    }
+    mapFeatures(row) {
+        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,
+        };
+    }
+    mapFleet(row) {
+        return {
+            productId: row.productId,
+            containerImage: row.containerImage,
+            containerPort: row.containerPort,
+            lifecycle: row.lifecycle,
+            billingModel: row.billingModel,
+            maxInstances: row.maxInstances,
+            imageAllowlist: row.imageAllowlist ?? null,
+            dockerNetwork: row.dockerNetwork,
+            placementStrategy: row.placementStrategy,
+            fleetDataDir: row.fleetDataDir,
+        };
+    }
+    mapBilling(row) {
+        return {
+            productId: row.productId,
+            stripePublishableKey: row.stripePublishableKey ?? null,
+            stripeSecretKey: row.stripeSecretKey ?? null,
+            stripeWebhookSecret: row.stripeWebhookSecret ?? null,
+            creditPrices: (row.creditPrices ?? {}),
+            affiliateBaseUrl: row.affiliateBaseUrl ?? null,
+            affiliateMatchRate: Number(row.affiliateMatchRate),
+            affiliateMaxCap: row.affiliateMaxCap,
+            dividendRate: Number(row.dividendRate),
+            marginConfig: row.marginConfig ?? null,
+        };
+    }
+}

package/dist/product-config/drizzle-product-config-repository.test.d.ts

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

package/dist/product-config/drizzle-product-config-repository.test.js

@@ -0,0 +1,114 @@
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+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;
+    let pool;
+    let repo;
+    beforeAll(async () => {
+        const result = await createTestDb();
+        db = result.db;
+        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/dist/product-config/index.d.ts

@@ -0,0 +1,24 @@
+import type { DrizzleDb } from "../db/index.js";
+import type { PlatformBootOptions, PlatformBootResult } from "./boot.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 declare function platformBoot(opts: PlatformBootOptions): Promise<PlatformBootResult>;
+export { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+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";
+/** Initialize the product config system. Call once at startup. */
+export declare function initProductConfig(db: DrizzleDb): ProductConfigService;
+/** Initialize with a custom repository (for testing). */
+export declare function initProductConfigWithRepo(repo: IProductConfigRepository): ProductConfigService;
+/**
+ * Get the product config service.
+ * This is the ONLY way to access product config — reads are cached,
+ * writes auto-invalidate the cache.
+ */
+export declare function getProductConfigService(): ProductConfigService;

package/dist/product-config/index.js

@@ -0,0 +1,37 @@
+import { platformBoot as rawPlatformBoot } from "./boot.js";
+import { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+import { ProductConfigService } from "./service.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) {
+    const result = await rawPlatformBoot(opts);
+    _service = result.service;
+    return result;
+}
+export { DrizzleProductConfigRepository } from "./drizzle-product-config-repository.js";
+export { deriveCorsOrigins, toBrandConfig } from "./repository-types.js";
+export { ProductConfigService } from "./service.js";
+let _service = null;
+/** Initialize the product config system. Call once at startup. */
+export function initProductConfig(db) {
+    const repo = new DrizzleProductConfigRepository(db);
+    _service = new ProductConfigService(repo);
+    return _service;
+}
+/** Initialize with a custom repository (for testing). */
+export function initProductConfigWithRepo(repo) {
+    _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() {
+    if (!_service)
+        throw new Error("Product config not initialized. Call initProductConfig() first.");
+    return _service;
+}

package/dist/product-config/repository-types.d.ts

@@ -0,0 +1,143 @@
+/** 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;
+}
+export interface ProductNavItem {
+    id: string;
+    productId: string;
+    label: string;
+    href: string;
+    icon: string | null;
+    sortOrder: number;
+    requiresRole: string | null;
+    enabled: boolean;
+}
+export interface ProductDomain {
+    id: string;
+    productId: string;
+    host: string;
+    role: "canonical" | "redirect";
+}
+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;
+}
+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;
+}
+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;
+}
+/** 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;
+    }>;
+}
+/** 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>;
+}
+/** Derive CORS origins from product config. */
+/** Derive CORS origins — excludes redirect-only domains (they 301, never make requests). */
+export declare function deriveCorsOrigins(product: Product, domains: ProductDomain[]): string[];
+/**
+ * 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 declare function toBrandConfig(config: ProductConfig, userRole?: string): ProductBrandConfig;

package/dist/product-config/repository-types.js

@@ -0,0 +1,53 @@
+// src/product-config/repository-types.ts
+//
+// Plain TypeScript interfaces for product configuration domain.
+// No Drizzle types. These are the contract all consumers work against.
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Derive CORS origins from product config. */
+/** Derive CORS origins — excludes redirect-only domains (they 301, never make requests). */
+export function deriveCorsOrigins(product, domains) {
+    const origins = new Set();
+    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, userRole) {
+    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/dist/product-config/service.d.ts

@@ -0,0 +1,27 @@
+import type { IProductConfigRepository, NavItemInput, Product, ProductBillingConfig, ProductBrandConfig, ProductBrandUpdate, ProductConfig, ProductFeatures, ProductFleetConfig } from "./repository-types.js";
+/**
+ * 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 declare class ProductConfigService {
+    private repo;
+    private cache;
+    private ttlMs;
+    constructor(repo: IProductConfigRepository, opts?: {
+        ttlMs?: number;
+    });
+    getBySlug(slug: string): Promise<ProductConfig | null>;
+    getBrandConfig(slug: string): Promise<ProductBrandConfig | null>;
+    listAll(): Promise<ProductConfig[]>;
+    upsertProduct(slug: string, data: ProductBrandUpdate): Promise<Product>;
+    replaceNavItems(slug: string, productId: string, items: NavItemInput[]): Promise<void>;
+    upsertFeatures(slug: string, productId: string, data: Partial<ProductFeatures>): Promise<void>;
+    upsertFleetConfig(slug: string, productId: string, data: Partial<ProductFleetConfig>): Promise<void>;
+    upsertBillingConfig(slug: string, productId: string, data: Partial<ProductBillingConfig>): Promise<void>;
+    invalidate(slug: string): void;
+    invalidateAll(): void;
+}