@voyant-travel/inventory 0.1.0

package/dist/authoring/clone.js

@@ -0,0 +1,142 @@
+import { eq, inArray, sql } from "drizzle-orm";
+import { optionUnits, productOptions, products } from "../schema.js";
+import { productsService } from "../service.js";
+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/operations — 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) {
+            // agent-quality: raw-sql reviewed -- owner: catalog-authoring; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+            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/authoring/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/authoring/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/authoring/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/authoring/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/authoring/extension.d.ts

@@ -0,0 +1,248 @@
+import type { EventBus } from "@voyant-travel/core";
+import type { HonoExtension } from "@voyant-travel/hono/module";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+/**
+ * Inventory authoring rides on the `products` admin prefix as a HonoExtension, so
+ * its routes land at `/v1/admin/products/...` while the implementation lives
+ * with the optional Inventory package. Same mechanism as
+ * `bookingsSupplierExtension`.
+ *
+ *   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)
+ *
+ * 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 inventoryAuthoringRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/compose": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+                issues: {
+                    code: string;
+                    field?: string | undefined;
+                    message: string;
+                    fix?: string | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 422;
+        } | {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    options: {
+                        ref: string;
+                        id: string;
+                        units: {
+                            ref: string;
+                            id: string;
+                        }[];
+                    }[];
+                };
+            };
+            outputFormat: "json";
+            status: 200 | 201;
+        };
+    };
+} & {
+    "/:id/duplicate": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    status: "draft" | "active" | "archived";
+                    description: string | null;
+                    inclusionsHtml: string | null;
+                    exclusionsHtml: string | null;
+                    termsHtml: string | null;
+                    termsShowOnContract: boolean;
+                    bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+                    capacityMode: "free_sale" | "limited" | "on_request";
+                    timezone: string | null;
+                    defaultLanguageTag: string | null;
+                    visibility: "public" | "private" | "hidden";
+                    activated: boolean;
+                    reservationTimeoutMinutes: number | null;
+                    sellCurrency: string;
+                    sellAmountCents: number | null;
+                    costAmountCents: number | null;
+                    marginPercent: number | null;
+                    facilityId: string | null;
+                    supplierId: string | null;
+                    startDate: string | null;
+                    endDate: string | null;
+                    pax: number | null;
+                    productTypeId: string | null;
+                    contractTemplateId: string | null;
+                    taxClassId: string | null;
+                    customerPaymentPolicy: import("hono/utils/types").JSONValue;
+                    tags: string[] | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+                options: {
+                    id: string;
+                    units: {
+                        id: string;
+                    }[];
+                }[];
+            };
+            outputFormat: "json";
+            status: 200 | 201;
+        };
+    };
+}, "/", "/:id/duplicate">;
+export declare const inventoryAuthoringExtension: HonoExtension;
+export declare const catalogAuthoringRoutes: import("hono/hono-base").HonoBase<Env, {
+    "/compose": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+                issues: {
+                    code: string;
+                    field?: string | undefined;
+                    message: string;
+                    fix?: string | undefined;
+                }[];
+            };
+            outputFormat: "json";
+            status: 422;
+        } | {
+            input: {};
+            output: {
+                data: {
+                    id: string;
+                    options: {
+                        ref: string;
+                        id: string;
+                        units: {
+                            ref: string;
+                            id: string;
+                        }[];
+                    }[];
+                };
+            };
+            outputFormat: "json";
+            status: 200 | 201;
+        };
+    };
+} & {
+    "/:id/duplicate": {
+        $post: {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 404;
+        } | {
+            input: {
+                param: {
+                    id: string;
+                };
+            };
+            output: {
+                data: {
+                    id: string;
+                    name: string;
+                    status: "draft" | "active" | "archived";
+                    description: string | null;
+                    inclusionsHtml: string | null;
+                    exclusionsHtml: string | null;
+                    termsHtml: string | null;
+                    termsShowOnContract: boolean;
+                    bookingMode: "date" | "date_time" | "open" | "stay" | "transfer" | "itinerary" | "other";
+                    capacityMode: "free_sale" | "limited" | "on_request";
+                    timezone: string | null;
+                    defaultLanguageTag: string | null;
+                    visibility: "public" | "private" | "hidden";
+                    activated: boolean;
+                    reservationTimeoutMinutes: number | null;
+                    sellCurrency: string;
+                    sellAmountCents: number | null;
+                    costAmountCents: number | null;
+                    marginPercent: number | null;
+                    facilityId: string | null;
+                    supplierId: string | null;
+                    startDate: string | null;
+                    endDate: string | null;
+                    pax: number | null;
+                    productTypeId: string | null;
+                    contractTemplateId: string | null;
+                    taxClassId: string | null;
+                    customerPaymentPolicy: import("hono/utils/types").JSONValue;
+                    tags: string[] | null;
+                    createdAt: string;
+                    updatedAt: string;
+                };
+                options: {
+                    id: string;
+                    units: {
+                        id: string;
+                    }[];
+                }[];
+            };
+            outputFormat: "json";
+            status: 200 | 201;
+        };
+    };
+}, "/", "/:id/duplicate">;
+export declare const catalogAuthoringExtension: HonoExtension;
+export {};
+//# sourceMappingURL=extension.d.ts.map

package/dist/authoring/extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension.d.ts","sourceRoot":"","sources":["../../src/authoring/extension.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAa,MAAM,qBAAqB,CAAA;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAcjE;;;;;;;;;;;;;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,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA6DjC,CAAA;AAYJ,eAAO,MAAM,2BAA2B,EAAE,aAGzC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAA2B,CAAA;AAE9D,eAAO,MAAM,yBAAyB,EAAE,aAMvC,CAAA"}

package/dist/authoring/extension.js

@@ -0,0 +1,116 @@
+import { parseJsonBody } from "@voyant-travel/hono";
+import { Hono } from "hono";
+import { z } from "zod";
+import { appendProductMutationLedgerEntry, } from "../action-ledger.js";
+import { emitProductContentChanged } from "../events.js";
+import { productStatusEnum, productVisibilityEnum } from "../schema.js";
+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 inventoryAuthoringRoutes = new Hono()
+    .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 inventoryAuthoringExtensionDef = {
+    name: "inventory-authoring",
+    module: "products",
+    // The compose + duplicate routes run interactive transactions
+    // (atomic clone of the product graph). This extension mounts under
+    // /v1/admin/products, so the flag upgrades that surface to the
+    // transaction-capable db client in deployments that split factories.
+    requiresTransactionalDb: true,
+};
+export const inventoryAuthoringExtension = {
+    extension: inventoryAuthoringExtensionDef,
+    adminRoutes: inventoryAuthoringRoutes,
+};
+export const catalogAuthoringRoutes = inventoryAuthoringRoutes;
+export const catalogAuthoringExtension = {
+    extension: {
+        ...inventoryAuthoringExtensionDef,
+        name: "catalog-authoring",
+    },
+    adminRoutes: inventoryAuthoringRoutes,
+};

package/dist/authoring/index.d.ts

@@ -0,0 +1,12 @@
+import type { Module } from "@voyant-travel/core";
+export declare const inventoryAuthoringModule: 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, inventoryAuthoringExtension, inventoryAuthoringRoutes, } from "./extension.js";
+export type { NewProductAuthoringRequest, ProductAuthoringRequest } from "./schema.js";
+export { productAuthoringRequests } from "./schema.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/authoring/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/authoring/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAEjD,eAAO,MAAM,wBAAwB,EAAE,MAEtC,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,EACL,yBAAyB,EACzB,sBAAsB,EACtB,2BAA2B,EAC3B,wBAAwB,GACzB,MAAM,gBAAgB,CAAA;AACvB,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/authoring/index.js

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

package/dist/authoring/schema.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Dedup ledger for clone/compose. A clone or compose has no natural key
+ * (product names may collide), so we cannot reuse the booking-create
+ * advisory-lock-on-natural-key guard. Instead, callers (agent tool runtimes)
+ * pass an `Idempotency-Key`; a retried/double-tapped request with the same key
+ * returns the originally-created product id instead of building a second graph.
+ */
+export declare const productAuthoringRequests: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "product_authoring_requests";
+    schema: undefined;
+    columns: {
+        idempotencyKey: import("drizzle-orm/pg-core").PgColumn<{
+            name: "idempotency_key";
+            tableName: "product_authoring_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "product_authoring_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        operation: import("drizzle-orm/pg-core").PgColumn<{
+            name: "operation";
+            tableName: "product_authoring_requests";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "product_authoring_requests";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export type ProductAuthoringRequest = typeof productAuthoringRequests.$inferSelect;
+export type NewProductAuthoringRequest = typeof productAuthoringRequests.$inferInsert;
+//# sourceMappingURL=schema.d.ts.map

package/dist/authoring/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/authoring/schema.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAWpC,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAA;AAClF,MAAM,MAAM,0BAA0B,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAA"}