@voyantjs/catalog-authoring 0.104.1 → 0.106.0

package/dist/clone.js

@@ -0,0 +1,141 @@
+import { productsService } from "@voyantjs/products";
+import { optionUnits, productOptions, products } from "@voyantjs/products/schema";
+import { eq, inArray, sql } from "drizzle-orm";
+import { copyProductContent, withoutSystemColumns } from "./clone-content.js";
+import { copyPricingAndAvailability } from "./clone-pricing.js";
+import { productAuthoringRequests } from "./schema.js";
+function copyName(name) {
+    return `${name} (Copy)`;
+}
+/**
+ * Reads a product's options + units back into the {@link ClonedOption} shape.
+ * Used to reconstruct the result for an idempotent retry, so a re-sent clone
+ * returns the same option/unit ids a fresh response would (the agent needs them
+ * to continue authoring after the exact lost-response case idempotency covers).
+ */
+async function loadClonedOptions(tx, productId) {
+    const optionRows = await tx
+        .select({ id: productOptions.id })
+        .from(productOptions)
+        .where(eq(productOptions.productId, productId));
+    if (optionRows.length === 0)
+        return [];
+    const unitRows = await tx
+        .select({ id: optionUnits.id, optionId: optionUnits.optionId })
+        .from(optionUnits)
+        .where(inArray(optionUnits.optionId, optionRows.map((o) => o.id)));
+    return optionRows.map((o) => ({
+        id: o.id,
+        units: unitRows.filter((u) => u.optionId === o.id).map((u) => ({ id: u.id })),
+    }));
+}
+function newContext(tx, sourceId, targetId, copyDepartures) {
+    return {
+        tx,
+        sourceId,
+        targetId,
+        copyDepartures,
+        optionIdMap: new Map(),
+        unitIdMap: new Map(),
+        unitsByNewOption: new Map(),
+        itineraryIdMap: new Map(),
+        dayIdMap: new Map(),
+        startTimeIdMap: new Map(),
+        ruleIdMap: new Map(),
+        slotIdMap: new Map(),
+        optionPriceRuleIdMap: new Map(),
+        optionUnitPriceRuleIdMap: new Map(),
+        pricingCategoryIdMap: new Map(),
+        productExtraIdMap: new Map(),
+        optionExtraConfigIdMap: new Map(),
+    };
+}
+/**
+ * Deep-clone a product graph as a draft (#1493): the new product row, then its
+ * content (options/units, pricing categories, itinerary, media, extras) and its
+ * pricing/availability — copied with correct id remapping. Availability is
+ * copied only when `copyDepartures`. MUST run inside the caller's transaction.
+ */
+async function cloneGraph(tx, sourceId, opts) {
+    const [sourceProduct] = await tx.select().from(products).where(eq(products.id, sourceId));
+    if (!sourceProduct)
+        return null;
+    const [targetProduct] = await tx
+        .insert(products)
+        .values({
+        ...withoutSystemColumns(sourceProduct),
+        name: opts.name ?? copyName(sourceProduct.name),
+        status: opts.status ?? "draft",
+        ...(opts.visibility ? { visibility: opts.visibility } : {}),
+        activated: false,
+    })
+        .returning();
+    if (!targetProduct) {
+        throw new Error("Failed to duplicate product");
+    }
+    const ctx = newContext(tx, sourceId, targetProduct.id, opts.copyDepartures);
+    await copyProductContent(ctx);
+    await copyPricingAndAvailability(ctx);
+    const options = [...ctx.optionIdMap.values()].map((id) => ({
+        id,
+        units: ctx.unitsByNewOption.get(id) ?? [],
+    }));
+    return { product: targetProduct, options };
+}
+/**
+ * Deep-clone a product (#1493). Wraps {@link cloneGraph} with idempotency and an
+ * optional `product_versions` snapshot. The operator UI calls this with no
+ * overrides (full copy, `"{X} (Copy)"`, departures included); the agent passes
+ * `name` + `copyDepartures: false` + an `Idempotency-Key`.
+ */
+export async function cloneProduct(db, sourceProductId, options = {}) {
+    const [exists] = await db
+        .select({ id: products.id })
+        .from(products)
+        .where(eq(products.id, sourceProductId))
+        .limit(1);
+    if (!exists)
+        return { status: "not_found" };
+    const copyDepartures = options.copyDepartures ?? true;
+    const key = options.idempotencyKey;
+    const result = await db.transaction(async (tx) => {
+        if (key) {
+            await tx.execute(sql `SELECT pg_advisory_xact_lock(hashtextextended(${key}, 0))`);
+            const [prev] = await tx
+                .select({ productId: productAuthoringRequests.productId })
+                .from(productAuthoringRequests)
+                .where(eq(productAuthoringRequests.idempotencyKey, key))
+                .limit(1);
+            if (prev) {
+                const [product] = await tx
+                    .select()
+                    .from(products)
+                    .where(eq(products.id, prev.productId))
+                    .limit(1);
+                if (product) {
+                    return { product, options: await loadClonedOptions(tx, product.id), reused: true };
+                }
+            }
+        }
+        const cloned = await cloneGraph(tx, sourceProductId, {
+            name: options.name,
+            status: options.status,
+            visibility: options.visibility,
+            copyDepartures,
+        });
+        if (!cloned)
+            return null;
+        if (options.userId) {
+            await productsService.createVersion(tx, cloned.product.id, options.userId, {});
+        }
+        if (key) {
+            await tx
+                .insert(productAuthoringRequests)
+                .values({ idempotencyKey: key, productId: cloned.product.id, operation: "duplicate" });
+        }
+        return { ...cloned, reused: false };
+    });
+    if (!result)
+        return { status: "not_found" };
+    return { status: "ok", ...result };
+}

package/dist/errors.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A single, agent-recoverable problem. The shape is deliberately verbose so an
+ * LLM tool runtime can fix the spec and retry without a human: `field` says
+ * what to change, `message` says why, `fix` says how.
+ */
+export interface AuthoringIssue {
+    code: string;
+    field?: string;
+    message: string;
+    fix?: string;
+}
+/**
+ * Thrown by the validator (and the builder, for structural problems it can only
+ * detect mid-build, e.g. an unresolved catalog). Routes translate this to a 422
+ * with `{ errors }` so the caller can self-correct.
+ */
+export declare class AuthoringValidationError extends Error {
+    readonly issues: AuthoringIssue[];
+    constructor(issues: AuthoringIssue[]);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,QAAQ,CAAC,MAAM,EAAE,cAAc,EAAE,CAAA;gBAErB,MAAM,EAAE,cAAc,EAAE;CAKrC"}

package/dist/errors.js

@@ -0,0 +1,13 @@
+/**
+ * Thrown by the validator (and the builder, for structural problems it can only
+ * detect mid-build, e.g. an unresolved catalog). Routes translate this to a 422
+ * with `{ errors }` so the caller can self-correct.
+ */
+export class AuthoringValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(issues.map((i) => i.message).join("; ") || "Invalid product graph");
+        this.name = "AuthoringValidationError";
+        this.issues = issues;
+    }
+}

package/dist/extension.d.ts

@@ -1,21 +1,25 @@
+import type { EventBus } from "@voyantjs/core";
 import type { HonoExtension } from "@voyantjs/hono/module";
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
 /**
- * Catalog authoring rides on the `products` admin prefix as a HonoExtension,
- * so its routes land at `/v1/admin/products/...` without `packages/products`
+ * Catalog authoring rides on the `products` admin prefix as a HonoExtension, so
+ * its routes land at `/v1/admin/products/...` without `packages/products`
  * depending on this package (which would cycle, since this package depends on
  * both products and pricing). Same mechanism as `bookingsSupplierExtension`.
  *
- *   POST /v1/admin/products/{id}/duplicate   — clone   (#1493)
- *   POST /v1/admin/products/compose          — compose (#1495)
+ *   POST /v1/admin/products/{id}/duplicate — deep-clone a product graph (#1493)
+ *   POST /v1/admin/products/compose        — build a new product graph from a spec (#1495)
  *
- * Phase 0: routes are mounted but not yet implemented. The builder, clone,
- * validator and compose land in later phases.
+ * The duplicate route is the canonical product clone (it replaces the operator
+ * template's previous local `duplicateProductAsDraft` route). No body → a full
+ * copy named `"{X} (Copy)"` with departures (preserves the UI). The agent passes
+ * `{ name, copyDepartures: false }` + an `Idempotency-Key`.
  */
 type Env = {
     Variables: {
         db: PostgresJsDatabase;
         userId?: string;
+        eventBus?: EventBus;
     };
 };
 export declare const catalogAuthoringRoutes: import("hono/hono-base").HonoBase<Env, {
@@ -24,9 +28,32 @@ export declare const catalogAuthoringRoutes: import("hono/hono-base").HonoBase<E
             input: {};
             output: {
                 error: string;
+                issues: {
+                    code: string;
+                    field?: string | undefined;
+                    message: string;
+                    fix?: string | undefined;
+                }[];
             };
             outputFormat: "json";
-            status: 501;
+            status: 422;
+        } | {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    options: {
+                        ref: string;
+                        id: string;
+                        units: {
+                            ref: string;
+                            id: string;
+                        }[];
+                    }[];
+                };
+            };
+            outputFormat: "json";
+            status: 200 | 201;
         };
     };
 } & {
@@ -41,7 +68,67 @@ export declare const catalogAuthoringRoutes: import("hono/hono-base").HonoBase<E
                 error: string;
             };
             outputFormat: "json";
-            status: 501;
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    createdAt: string;
+                    updatedAt: string;
+                    timezone: string | null;
+                    sellAmountCents: number | null;
+                    costAmountCents: number | null;
+                    description: string | null;
+                    facilityId: string | null;
+                    status: "active" | "draft" | "archived";
+                    startDate: string | null;
+                    endDate: string | null;
+                    inclusionsHtml: string | null;
+                    exclusionsHtml: string | null;
+                    termsHtml: string | null;
+                    termsShowOnContract: boolean;
+                    bookingMode: "other" | "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary";
+                    capacityMode: "on_request" | "free_sale" | "limited";
+                    defaultLanguageTag: string | null;
+                    visibility: "public" | "private" | "hidden";
+                    activated: boolean;
+                    reservationTimeoutMinutes: number | null;
+                    sellCurrency: string;
+                    marginPercent: number | null;
+                    supplierId: string | null;
+                    pax: number | null;
+                    productTypeId: string | null;
+                    contractTemplateId: string | null;
+                    taxClassId: string | null;
+                    customerPaymentPolicy: import("hono/utils/types").JSONValue;
+                    tags: string[] | null;
+                };
+                options: {
+                    id: string;
+                    units: {
+                        id: string;
+                    }[];
+                }[];
+            };
+            outputFormat: "json";
+            status: 200 | 201;
         };
     };
 }, "/", "/:id/duplicate">;

package/dist/extension.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE;;;;;;;;;;;GAWG;AAEH,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;yBAEwC,CAAA;AAO3E,eAAO,MAAM,yBAAyB,EAAE,aAGvC,CAAA"}
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,gBAAgB,CAAA;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAO1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAQjE;;;;;;;;;;;;;GAaG;AAEH,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,QAAQ,CAAC,EAAE,QAAQ,CAAA;KACpB,CAAA;CACF,CAAA;AAmDD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA6D/B,CAAA;AAOJ,eAAO,MAAM,yBAAyB,EAAE,aAGvC,CAAA"}

package/dist/extension.js

@@ -1,7 +1,97 @@
+import { parseJsonBody } from "@voyantjs/hono";
+import { appendProductMutationLedgerEntry, emitProductContentChanged, } from "@voyantjs/products";
+import { productStatusEnum, productVisibilityEnum } from "@voyantjs/products/schema";
 import { Hono } from "hono";
+import { z } from "zod";
+import { cloneProduct } from "./clone.js";
+import { composeProduct } from "./service.js";
+import { productGraphSpecSchema } from "./spec.js";
+const composeBodySchema = z.object({
+    spec: productGraphSpecSchema,
+    idempotencyKey: z.string().min(1).max(255).optional(),
+});
+const duplicateBodySchema = z.object({
+    name: z.string().min(1).max(255).optional(),
+    status: z.enum(productStatusEnum.enumValues).optional(),
+    visibility: z.enum(productVisibilityEnum.enumValues).optional(),
+    copyDepartures: z.boolean().optional(),
+    idempotencyKey: z.string().min(1).max(255).optional(),
+});
+/** Header takes precedence over a body-supplied key. */
+function idempotencyKey(c, bodyKey) {
+    return c.req.header("Idempotency-Key") ?? bodyKey;
+}
+/**
+ * Records the same action-ledger entry + `product.content.changed` event the
+ * granular product routes emit, so an authored product is indexed and audited
+ * like any other create. Only called for freshly built products (a reused
+ * idempotent response created nothing new).
+ */
+async function recordAuthoring(
+// biome-ignore lint/suspicious/noExplicitAny: bridges this extension's Env to products' ledger Context<Env> (#1493/#1495); cast to LedgerContext below
+c, action, productId) {
+    const verb = action === "duplicate" ? "duplicate" : "compose";
+    await appendProductMutationLedgerEntry(c, {
+        action,
+        productId,
+        changedFields: [],
+        subject: "product",
+        actionName: `product.${verb}`,
+        routeOrToolName: `products.${verb}`,
+    });
+    await emitProductContentChanged(c.get("eventBus"), { id: productId, axis: "product" });
+}
 export const catalogAuthoringRoutes = new Hono()
-    .post("/compose", (c) => c.json({ error: "not_implemented" }, 501))
-    .post("/:id/duplicate", (c) => c.json({ error: "not_implemented" }, 501));
+    .post("/compose", async (c) => {
+    const body = await parseJsonBody(c, composeBodySchema);
+    const outcome = await composeProduct(c.get("db"), body.spec, {
+        userId: c.get("userId"),
+        idempotencyKey: idempotencyKey(c, body.idempotencyKey),
+    });
+    if (outcome.status === "invalid") {
+        return c.json({ error: "invalid_product_graph", issues: outcome.issues }, 422);
+    }
+    if (!outcome.reused) {
+        await recordAuthoring(c, "create", outcome.result.productId);
+    }
+    return c.json({ data: { id: outcome.result.productId, options: outcome.result.options } }, outcome.reused ? 200 : 201);
+})
+    .post("/:id/duplicate", async (c) => {
+    // The UI clones with no body; the agent sends overrides. Tolerate both.
+    const raw = (await c.req.text()).trim();
+    let body = {};
+    if (raw.length > 0) {
+        let json;
+        try {
+            json = JSON.parse(raw);
+        }
+        catch {
+            return c.json({ error: "Invalid JSON body" }, 400);
+        }
+        const parsed = duplicateBodySchema.safeParse(json);
+        if (!parsed.success) {
+            return c.json({ error: "Invalid body", issues: parsed.error.issues }, 400);
+        }
+        body = parsed.data;
+    }
+    const outcome = await cloneProduct(c.get("db"), c.req.param("id"), {
+        name: body.name,
+        status: body.status,
+        visibility: body.visibility,
+        copyDepartures: body.copyDepartures,
+        userId: c.get("userId"),
+        idempotencyKey: idempotencyKey(c, body.idempotencyKey),
+    });
+    if (outcome.status === "not_found") {
+        return c.json({ error: "Product not found" }, 404);
+    }
+    if (!outcome.reused) {
+        await recordAuthoring(c, "duplicate", outcome.product.id);
+    }
+    // `data` stays the full product row (the UI reads `data.id`); `options`
+    // carries the cloned option/unit ids for agent follow-up calls.
+    return c.json({ data: outcome.product, options: outcome.options }, outcome.reused ? 200 : 201);
+});
 const catalogAuthoringExtensionDef = {
     name: "catalog-authoring",
     module: "products",

package/dist/index.d.ts

@@ -1,7 +1,12 @@
 import type { Module } from "@voyantjs/core";
 export declare const catalogAuthoringModule: Module;
+export { type BuildProductGraphOptions, type BuildProductGraphResult, buildProductGraph, } from "./builder.js";
+export { type ClonedOption, type CloneProductOptions, type CloneProductOutcome, cloneProduct, } from "./clone.js";
+export { type AuthoringIssue, AuthoringValidationError } from "./errors.js";
 export { catalogAuthoringExtension, catalogAuthoringRoutes } from "./extension.js";
 export type { NewProductAuthoringRequest, ProductAuthoringRequest } from "./schema.js";
 export { productAuthoringRequests } from "./schema.js";
-export { type ProductGraphSpec, productGraphSpecSchema, } from "./spec.js";
+export { type AuthoringRunOptions, type ComposeProductOutcome, composeProduct, } from "./service.js";
+export { type ProductGraphSpec, productGraphSpecSchema } from "./spec.js";
+export { validateProductGraph } from "./validate.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,eAAO,MAAM,sBAAsB,EAAE,MAEpC,CAAA;AAED,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAClF,YAAY,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AACtF,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EACL,KAAK,gBAAgB,EACrB,sBAAsB,GACvB,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAE5C,eAAO,MAAM,sBAAsB,EAAE,MAEpC,CAAA;AAED,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,iBAAiB,GAClB,MAAM,cAAc,CAAA;AACrB,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,YAAY,GACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,KAAK,cAAc,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAC3E,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AAClF,YAAY,EAAE,0BAA0B,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAA;AACtF,OAAO,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AACtD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,cAAc,GACf,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAA;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA"}

package/dist/index.js

@@ -1,6 +1,11 @@
 export const catalogAuthoringModule = {
     name: "catalog-authoring",
 };
+export { buildProductGraph, } from "./builder.js";
+export { cloneProduct, } from "./clone.js";
+export { AuthoringValidationError } from "./errors.js";
 export { catalogAuthoringExtension, catalogAuthoringRoutes } from "./extension.js";
 export { productAuthoringRequests } from "./schema.js";
-export { productGraphSpecSchema, } from "./spec.js";
+export { composeProduct, } from "./service.js";
+export { productGraphSpecSchema } from "./spec.js";
+export { validateProductGraph } from "./validate.js";

package/dist/service.d.ts

@@ -0,0 +1,28 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type BuildProductGraphResult } from "./builder.js";
+import { type AuthoringIssue } from "./errors.js";
+import type { ProductGraphSpec } from "./spec.js";
+export interface AuthoringRunOptions {
+    userId?: string;
+    /** Dedup key; a retried request with the same key returns the first result. */
+    idempotencyKey?: string;
+}
+export type ComposeProductOutcome = {
+    status: "ok";
+    result: BuildProductGraphResult;
+    reused: boolean;
+} | {
+    status: "invalid";
+    issues: AuthoringIssue[];
+};
+/**
+ * Compose a brand-new product graph from a caller-supplied spec (#1495). Runs the
+ * category validator first; an invalid spec is returned (never built) so the
+ * caller can self-correct. Rules without a catalog fall back to the operator
+ * default.
+ *
+ * Cloning an existing product lives in `clone.ts` (`cloneProduct`); this module
+ * is the from-scratch path. See #1493 / #1495.
+ */
+export declare function composeProduct(db: PostgresJsDatabase, spec: ProductGraphSpec, options?: AuthoringRunOptions): Promise<ComposeProductOutcome>;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,EAAE,KAAK,uBAAuB,EAAqB,MAAM,cAAc,CAAA;AAC9E,OAAO,EAAE,KAAK,cAAc,EAA4B,MAAM,aAAa,CAAA;AAE3E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAGjD,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,+EAA+E;IAC/E,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,MAAM,qBAAqB,GAC7B;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,uBAAuB,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,GAClE;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,cAAc,EAAE,CAAA;CAAE,CAAA;AAgDnD;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,gBAAgB,EACtB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,qBAAqB,CAAC,CAmBhC"}

package/dist/service.js

@@ -0,0 +1,65 @@
+import { priceCatalogs } from "@voyantjs/pricing/schema";
+import { and, eq, sql } from "drizzle-orm";
+import { buildProductGraph } from "./builder.js";
+import { AuthoringValidationError } from "./errors.js";
+import { productAuthoringRequests } from "./schema.js";
+import { validateProductGraph } from "./validate.js";
+/** Resolves the operator's default price catalog id, if one exists. */
+async function getDefaultCatalogId(db) {
+    const [row] = await db
+        .select({ id: priceCatalogs.id })
+        .from(priceCatalogs)
+        .where(and(eq(priceCatalogs.isDefault, true), eq(priceCatalogs.active, true)))
+        .limit(1);
+    return row?.id;
+}
+/**
+ * Resolves an idempotency key inside an open transaction. Returns the previously
+ * created product id when the key has been seen, else runs `build`, records the
+ * key, and returns the fresh result. The advisory lock serializes concurrent
+ * requests sharing a key (the booking-create guard pattern).
+ */
+async function withIdempotency(tx, key, operation, build) {
+    if (!key) {
+        return { result: await build(), reused: false };
+    }
+    await tx.execute(sql `SELECT pg_advisory_xact_lock(hashtextextended(${key}, 0))`);
+    const [existing] = await tx
+        .select({ productId: productAuthoringRequests.productId })
+        .from(productAuthoringRequests)
+        .where(eq(productAuthoringRequests.idempotencyKey, key))
+        .limit(1);
+    if (existing) {
+        return { result: { productId: existing.productId, options: [] }, reused: true };
+    }
+    const result = await build();
+    await tx
+        .insert(productAuthoringRequests)
+        .values({ idempotencyKey: key, productId: result.productId, operation });
+    return { result, reused: false };
+}
+/**
+ * Compose a brand-new product graph from a caller-supplied spec (#1495). Runs the
+ * category validator first; an invalid spec is returned (never built) so the
+ * caller can self-correct. Rules without a catalog fall back to the operator
+ * default.
+ *
+ * Cloning an existing product lives in `clone.ts` (`cloneProduct`); this module
+ * is the from-scratch path. See #1493 / #1495.
+ */
+export async function composeProduct(db, spec, options = {}) {
+    const issues = validateProductGraph(spec);
+    if (issues.length)
+        return { status: "invalid", issues };
+    const defaultCatalogId = await getDefaultCatalogId(db);
+    try {
+        const { result, reused } = await db.transaction((tx) => withIdempotency(tx, options.idempotencyKey, "compose", () => buildProductGraph(tx, spec, { userId: options.userId, defaultCatalogId })));
+        return { status: "ok", result, reused };
+    }
+    catch (error) {
+        if (error instanceof AuthoringValidationError) {
+            return { status: "invalid", issues: error.issues };
+        }
+        throw error;
+    }
+}