@voyantjs/products 0.52.1 → 0.52.3

package/dist/action-ledger-drift.d.ts

@@ -0,0 +1,29 @@
+import type { AnyDrizzleDb } from "@voyantjs/db";
+import { type SQL } from "drizzle-orm";
+export type ProductActionLedgerDriftCheck = "product" | "product_option" | "option_unit" | "product_itinerary" | "product_day" | "product_day_service" | "product_media" | "product_capability" | "product_delivery_format";
+export interface CheckProductActionLedgerDriftInput {
+    createdAtFrom?: Date | string | null;
+    sampleLimit?: number | null;
+}
+export interface ProductActionLedgerDriftRow {
+    check: ProductActionLedgerDriftCheck;
+    missingCount: number;
+    sampleIds: string[];
+}
+export interface CheckProductActionLedgerDriftResult {
+    ok: boolean;
+    rows: ProductActionLedgerDriftRow[];
+}
+interface ProductActionLedgerDriftQueryRow extends Record<string, unknown> {
+    check: ProductActionLedgerDriftCheck;
+    missing_count: number | string;
+    sample_ids: string[] | null;
+}
+export declare function buildProductActionLedgerDriftQueries(input?: CheckProductActionLedgerDriftInput): Record<ProductActionLedgerDriftCheck, SQL<ProductActionLedgerDriftQueryRow>>;
+export declare function checkProductActionLedgerDrift(db: AnyDrizzleDb, input?: CheckProductActionLedgerDriftInput): Promise<CheckProductActionLedgerDriftResult>;
+declare function normalizeRow(row: ProductActionLedgerDriftQueryRow): ProductActionLedgerDriftRow;
+export declare const __test__: {
+    normalizeRow: typeof normalizeRow;
+};
+export {};
+//# sourceMappingURL=action-ledger-drift.d.ts.map

package/dist/action-ledger-drift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-ledger-drift.d.ts","sourceRoot":"","sources":["../src/action-ledger-drift.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,aAAa,CAAA;AA6B5D,MAAM,MAAM,6BAA6B,GACrC,SAAS,GACT,gBAAgB,GAChB,aAAa,GACb,mBAAmB,GACnB,aAAa,GACb,qBAAqB,GACrB,eAAe,GACf,oBAAoB,GACpB,yBAAyB,CAAA;AAE7B,MAAM,WAAW,kCAAkC;IACjD,aAAa,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,IAAI,CAAA;IACpC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5B;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,6BAA6B,CAAA;IACpC,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB;AAED,MAAM,WAAW,mCAAmC;IAClD,EAAE,EAAE,OAAO,CAAA;IACX,IAAI,EAAE,2BAA2B,EAAE,CAAA;CACpC;AAED,UAAU,gCAAiC,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IACxE,KAAK,EAAE,6BAA6B,CAAA;IACpC,aAAa,EAAE,MAAM,GAAG,MAAM,CAAA;IAC9B,UAAU,EAAE,MAAM,EAAE,GAAG,IAAI,CAAA;CAC5B;AAED,wBAAgB,oCAAoC,CAClD,KAAK,GAAE,kCAAuC,GAC7C,MAAM,CAAC,6BAA6B,EAAE,GAAG,CAAC,gCAAgC,CAAC,CAAC,CA0Q9E;AAED,wBAAsB,6BAA6B,CACjD,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,kCAAuC,GAC7C,OAAO,CAAC,mCAAmC,CAAC,CAqB9C;AAyBD,iBAAS,YAAY,CAAC,GAAG,EAAE,gCAAgC,GAAG,2BAA2B,CAMxF;AAED,eAAO,MAAM,QAAQ;;CAEpB,CAAA"}

package/dist/action-ledger-drift.js

@@ -0,0 +1,335 @@
+import { actionLedgerEntries } from "@voyantjs/action-ledger/schema";
+import { sql } from "drizzle-orm";
+import { optionUnits, productOptions, products } from "./schema-core.js";
+import { productDayServices, productDays, productItineraries, productMedia, } from "./schema-itinerary.js";
+import { productCapabilities, productDeliveryFormats } from "./schema-settings.js";
+const DEFAULT_SAMPLE_LIMIT = 20;
+const MAX_SAMPLE_LIMIT = 100;
+const PRODUCT_CREATE_ACTION_NAME = "product.create";
+const PRODUCT_OPTION_CREATE_ACTION_NAME = "product.option.create";
+const OPTION_UNIT_CREATE_ACTION_NAME = "product.option_unit.create";
+const PRODUCT_ITINERARY_CREATE_ACTION_NAMES = [
+    "product.itinerary.create",
+    "product.itinerary.duplicate",
+];
+const PRODUCT_DAY_CREATE_ACTION_NAME = "product.day.create";
+const PRODUCT_DAY_SERVICE_CREATE_ACTION_NAME = "product.day_service.create";
+const PRODUCT_MEDIA_CREATE_ACTION_NAME = "product.media.create";
+const PRODUCT_DAY_MEDIA_CREATE_ACTION_NAME = "product.day_media.create";
+const PRODUCT_BROCHURE_CREATE_ACTION_NAME = "product.brochure.create";
+const PRODUCT_CAPABILITY_CREATE_ACTION_NAME = "product.capability.create";
+const PRODUCT_DELIVERY_FORMAT_CREATE_ACTION_NAME = "product.delivery_format.create";
+export function buildProductActionLedgerDriftQueries(input = {}) {
+    const sampleLimit = normalizeSampleLimit(input.sampleLimit);
+    return {
+        product: sql `
+      SELECT
+        'product' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${products.id} AS candidate_id,
+          ${products.createdAt} AS created_at,
+          row_number() OVER (ORDER BY ${products.createdAt} DESC, ${products.id} DESC) AS sample_ordinal
+        FROM ${products}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(products.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = ${PRODUCT_CREATE_ACTION_NAME}
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${products.id}
+          )
+      ) missing
+    `,
+        product_option: sql `
+      SELECT
+        'product_option' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${productOptions.id} AS candidate_id,
+          ${productOptions.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${productOptions.createdAt} DESC, ${productOptions.id} DESC
+          ) AS sample_ordinal
+        FROM ${productOptions}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(productOptions.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = ${PRODUCT_OPTION_CREATE_ACTION_NAME}
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${productOptions.productId}
+          )
+      ) missing
+    `,
+        option_unit: sql `
+      SELECT
+        'option_unit' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${optionUnits.id} AS candidate_id,
+          ${optionUnits.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${optionUnits.createdAt} DESC, ${optionUnits.id} DESC
+          ) AS sample_ordinal
+        FROM ${optionUnits}
+        INNER JOIN ${productOptions} ON ${productOptions.id} = ${optionUnits.optionId}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(optionUnits.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = ${OPTION_UNIT_CREATE_ACTION_NAME}
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${productOptions.productId}
+          )
+      ) missing
+    `,
+        product_itinerary: sql `
+      SELECT
+        'product_itinerary' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${productItineraries.id} AS candidate_id,
+          ${productItineraries.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${productItineraries.createdAt} DESC, ${productItineraries.id} DESC
+          ) AS sample_ordinal
+        FROM ${productItineraries}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(productItineraries.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} IN (${sql.join(PRODUCT_ITINERARY_CREATE_ACTION_NAMES.map((actionName) => sql `${actionName}`), sql `, `)})
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${productItineraries.productId}
+          )
+      ) missing
+    `,
+        product_day: sql `
+      SELECT
+        'product_day' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${productDays.id} AS candidate_id,
+          ${productDays.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${productDays.createdAt} DESC, ${productDays.id} DESC
+          ) AS sample_ordinal
+        FROM ${productDays}
+        INNER JOIN ${productItineraries} ON ${productItineraries.id} = ${productDays.itineraryId}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(productDays.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = ${PRODUCT_DAY_CREATE_ACTION_NAME}
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${productItineraries.productId}
+          )
+      ) missing
+    `,
+        product_day_service: sql `
+      SELECT
+        'product_day_service' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${productDayServices.id} AS candidate_id,
+          ${productDayServices.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${productDayServices.createdAt} DESC, ${productDayServices.id} DESC
+          ) AS sample_ordinal
+        FROM ${productDayServices}
+        INNER JOIN ${productDays} ON ${productDays.id} = ${productDayServices.dayId}
+        INNER JOIN ${productItineraries} ON ${productItineraries.id} = ${productDays.itineraryId}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(productDayServices.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = ${PRODUCT_DAY_SERVICE_CREATE_ACTION_NAME}
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${productItineraries.productId}
+          )
+      ) missing
+    `,
+        product_media: sql `
+      SELECT
+        'product_media' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${productMedia.id} AS candidate_id,
+          ${productMedia.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${productMedia.createdAt} DESC, ${productMedia.id} DESC
+          ) AS sample_ordinal
+        FROM ${productMedia}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(productMedia.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = CASE
+                WHEN ${productMedia.isBrochure} = true THEN ${PRODUCT_BROCHURE_CREATE_ACTION_NAME}
+                WHEN ${productMedia.dayId} IS NOT NULL THEN ${PRODUCT_DAY_MEDIA_CREATE_ACTION_NAME}
+                ELSE ${PRODUCT_MEDIA_CREATE_ACTION_NAME}
+              END
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${productMedia.productId}
+          )
+      ) missing
+    `,
+        product_capability: sql `
+      SELECT
+        'product_capability' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${productCapabilities.id} AS candidate_id,
+          ${productCapabilities.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${productCapabilities.createdAt} DESC, ${productCapabilities.id} DESC
+          ) AS sample_ordinal
+        FROM ${productCapabilities}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(productCapabilities.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = ${PRODUCT_CAPABILITY_CREATE_ACTION_NAME}
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${productCapabilities.productId}
+          )
+      ) missing
+    `,
+        product_delivery_format: sql `
+      SELECT
+        'product_delivery_format' AS check,
+        count(*)::int AS missing_count,
+        coalesce(
+          array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+            FILTER (WHERE sample_ordinal <= ${sampleLimit}),
+          ARRAY[]::text[]
+        ) AS sample_ids
+      FROM (
+        SELECT
+          ${productDeliveryFormats.id} AS candidate_id,
+          ${productDeliveryFormats.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${productDeliveryFormats.createdAt} DESC, ${productDeliveryFormats.id} DESC
+          ) AS sample_ordinal
+        FROM ${productDeliveryFormats}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(productDeliveryFormats.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = ${PRODUCT_DELIVERY_FORMAT_CREATE_ACTION_NAME}
+              AND ${actionLedgerEntries.targetType} = ${"product"}
+              AND ${actionLedgerEntries.targetId} = ${productDeliveryFormats.productId}
+          )
+      ) missing
+    `,
+    };
+}
+export async function checkProductActionLedgerDrift(db, input = {}) {
+    const queries = buildProductActionLedgerDriftQueries(input);
+    const results = await Promise.all([
+        db.execute(queries.product),
+        db.execute(queries.product_option),
+        db.execute(queries.option_unit),
+        db.execute(queries.product_itinerary),
+        db.execute(queries.product_day),
+        db.execute(queries.product_day_service),
+        db.execute(queries.product_media),
+        db.execute(queries.product_capability),
+        db.execute(queries.product_delivery_format),
+    ]);
+    const rows = results
+        .flatMap((result) => extractRows(result))
+        .map((row) => normalizeRow(row));
+    return {
+        ok: rows.every((row) => row.missingCount === 0),
+        rows,
+    };
+}
+function normalizeSampleLimit(limit) {
+    if (!limit)
+        return DEFAULT_SAMPLE_LIMIT;
+    return Math.min(Math.max(Math.trunc(limit), 1), MAX_SAMPLE_LIMIT);
+}
+function buildCreatedAtCondition(column, value) {
+    if (!value)
+        return sql ``;
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        throw new Error("createdAtFrom must be a valid date");
+    }
+    return sql `AND ${column} >= ${date}`;
+}
+function extractRows(result) {
+    if (Array.isArray(result))
+        return result;
+    const maybeRows = result.rows;
+    return Array.isArray(maybeRows) ? maybeRows : [];
+}
+function normalizeRow(row) {
+    return {
+        check: row.check,
+        missingCount: Number(row.missing_count),
+        sampleIds: row.sample_ids ?? [],
+    };
+}
+export const __test__ = {
+    normalizeRow,
+};

package/dist/action-ledger.d.ts

@@ -0,0 +1,104 @@
+import { type ActionLedgerRequestContextValues } from "@voyantjs/action-ledger/request-context";
+import { type ActionLedgerTargetTimelinePage } from "@voyantjs/action-ledger/timeline";
+import type { Context } from "hono";
+import type { Env } from "./route-env.js";
+import type { Product } from "./schema.js";
+export declare const productActionLedgerQuerySchema: import("zod").ZodPipe<import("zod").ZodObject<{
+    cursorOccurredAt: import("zod").ZodOptional<import("zod").ZodString>;
+    cursorId: import("zod").ZodOptional<import("zod").ZodString>;
+    limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
+    cursor: {
+        occurredAt: string;
+        id: string;
+    } | undefined;
+    limit?: number | undefined;
+}, {
+    cursorOccurredAt?: string | undefined;
+    cursorId?: string | undefined;
+    limit?: number | undefined;
+}>>;
+export type ProductActionLedgerListResponse = ActionLedgerTargetTimelinePage;
+export type ProductLedgerMutationAction = "create" | "update" | "delete" | "duplicate";
+export declare function getProductActionLedgerRequestContext(c: Context<Env>): ActionLedgerRequestContextValues;
+export declare function changedProductFields(input: Partial<Product>, before: Product | null, after: Product | null): string[];
+export declare function changedMutationFields(input: object, before: Record<string, unknown> | null, after: Record<string, unknown> | null): string[];
+export declare function productMutationSummary(action: ProductLedgerMutationAction, fields: string[], subject?: string): string;
+export declare function appendProductMutationLedgerEntry(c: Context<Env>, input: {
+    action: ProductLedgerMutationAction;
+    productId: string;
+    changedFields: string[];
+    subject?: string;
+    actionName?: string;
+    routeOrToolName?: string;
+    summary?: string;
+}): Promise<import("@voyantjs/action-ledger/service").AppendActionLedgerEntryResult>;
+export declare function listProductActionLedger(c: Context<Env>): Promise<(Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    data: {
+        id: string;
+        actionName: string;
+        actionVersion: string;
+        actionKind: "execute" | "reverse" | "update" | "delete" | "read" | "create" | "approve" | "reject" | "compensate" | "duplicate";
+        status: "requested" | "awaiting_approval" | "approved" | "denied" | "succeeded" | "failed" | "reversed" | "compensated" | "expired" | "cancelled" | "superseded";
+        evaluatedRisk: "low" | "medium" | "high" | "critical";
+        actorType: string | null;
+        principalType: "user" | "api_key" | "agent" | "workflow" | "system";
+        principalId: string;
+        principalSubtype: string | null;
+        sessionId: string | null;
+        apiTokenId: string | null;
+        internalRequest: boolean;
+        delegatedByPrincipalType: "user" | "api_key" | "agent" | "workflow" | "system" | null;
+        delegatedByPrincipalId: string | null;
+        delegationId: string | null;
+        callerType: string | null;
+        organizationId: string | null;
+        routeOrToolName: string | null;
+        workflowRunId: string | null;
+        workflowStepId: string | null;
+        correlationId: string | null;
+        causationActionId: string | null;
+        idempotencyScope: string | null;
+        idempotencyKey: string | null;
+        idempotencyFingerprint: string | null;
+        targetType: string;
+        targetId: string;
+        capabilityId: string | null;
+        capabilityVersion: string | null;
+        authorizationSource: string | null;
+        approvalId: string | null;
+        amendsActionId: string | null;
+        occurredAt: string;
+        createdAt: string;
+        mutationSummary: string | null;
+    }[];
+    pageInfo: {
+        nextCursor: {
+            occurredAt: string;
+            id: string;
+        } | null;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+export declare const __test__: {
+    changedMutationFields: typeof changedMutationFields;
+    changedProductFields: typeof changedProductFields;
+    productMutationSummary: typeof productMutationSummary;
+    productActionLedgerQuerySchema: import("zod").ZodPipe<import("zod").ZodObject<{
+        cursorOccurredAt: import("zod").ZodOptional<import("zod").ZodString>;
+        cursorId: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodOptional<import("zod").ZodCoercedNumber<unknown>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
+        cursor: {
+            occurredAt: string;
+            id: string;
+        } | undefined;
+        limit?: number | undefined;
+    }, {
+        cursorOccurredAt?: string | undefined;
+        cursorId?: string | undefined;
+        limit?: number | undefined;
+    }>>;
+};
+//# sourceMappingURL=action-ledger.d.ts.map

package/dist/action-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-ledger.d.ts","sourceRoot":"","sources":["../src/action-ledger.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gCAAgC,EAEtC,MAAM,yCAAyC,CAAA;AAEhD,OAAO,EACL,KAAK,8BAA8B,EAGpC,MAAM,kCAAkC,CAAA;AAEzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAG1C,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;GAAwC,CAAA;AAEnF,MAAM,MAAM,+BAA+B,GAAG,8BAA8B,CAAA;AAC5E,MAAM,MAAM,2BAA2B,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAA;AAEtF,wBAAgB,oCAAoC,CAClD,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,GACd,gCAAgC,CAgBlC;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,EACvB,MAAM,EAAE,OAAO,GAAG,IAAI,EACtB,KAAK,EAAE,OAAO,GAAG,IAAI,GACpB,MAAM,EAAE,CAEV;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EACtC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GACpC,MAAM,EAAE,CAKV;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,2BAA2B,EACnC,MAAM,EAAE,MAAM,EAAE,EAChB,OAAO,SAAY,UASpB;AAED,wBAAsB,gCAAgC,CACpD,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EACf,KAAK,EAAE;IACL,MAAM,EAAE,2BAA2B,CAAA;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB,oFAgBF;AAED,wBAAsB,uBAAuB,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oEAmC5D;AAcD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;CAKpB,CAAA"}

package/dist/action-ledger.js

@@ -0,0 +1,100 @@
+import { appendActionLedgerMutation, } from "@voyantjs/action-ledger/request-context";
+import { actionLedgerService } from "@voyantjs/action-ledger/service";
+import { actionLedgerTargetTimelineQuerySchema, buildActionLedgerTargetTimelinePage, } from "@voyantjs/action-ledger/timeline";
+import { parseQuery } from "@voyantjs/hono";
+import { productsService } from "./service.js";
+export const productActionLedgerQuerySchema = actionLedgerTargetTimelineQuerySchema;
+export function getProductActionLedgerRequestContext(c) {
+    return {
+        userId: c.get("userId") ?? null,
+        agentId: c.get("agentId") ?? null,
+        workflowPrincipalId: c.get("workflowPrincipalId") ?? null,
+        principalSubtype: c.get("principalSubtype") ?? null,
+        sessionId: c.get("sessionId") ?? null,
+        apiTokenId: c.get("apiTokenId") ?? c.get("apiKeyId") ?? null,
+        callerType: c.get("callerType") ?? null,
+        actor: c.get("actor") ?? null,
+        isInternalRequest: c.get("isInternalRequest") ?? false,
+        organizationId: c.get("organizationId") ?? null,
+        workflowRunId: c.get("workflowRunId") ?? null,
+        workflowStepId: c.get("workflowStepId") ?? null,
+        correlationId: c.req.header("x-correlation-id") ?? c.req.header("x-request-id") ?? null,
+    };
+}
+export function changedProductFields(input, before, after) {
+    return changedMutationFields(input, before, after);
+}
+export function changedMutationFields(input, before, after) {
+    const fields = Object.keys(input).filter((field) => !ignoredMutationFields.has(field));
+    if (!before || !after)
+        return fields.sort();
+    return fields.filter((field) => !productValuesEqual(before[field], after[field])).sort();
+}
+export function productMutationSummary(action, fields, subject = "product") {
+    const formattedSubject = subject.trim() || "product";
+    if (action === "delete")
+        return `Deleted ${formattedSubject}`;
+    if (action === "duplicate")
+        return `Duplicated ${formattedSubject}`;
+    if (fields.length === 0)
+        return action === "create" ? `Created ${formattedSubject}` : `Updated ${formattedSubject}`;
+    const verb = action === "create" ? "Created" : "Updated";
+    return `${verb} ${formattedSubject} fields: ${fields.join(", ")}`;
+}
+export async function appendProductMutationLedgerEntry(c, input) {
+    return appendActionLedgerMutation(c.get("db"), {
+        context: getProductActionLedgerRequestContext(c),
+        actionName: input.actionName ?? `product.${input.action}`,
+        actionKind: input.action === "duplicate" ? "create" : input.action,
+        evaluatedRisk: "medium",
+        targetType: "product",
+        targetId: input.productId,
+        routeOrToolName: input.routeOrToolName ?? `products.${input.action}`,
+        mutationDetail: {
+            summary: input.summary ?? productMutationSummary(input.action, input.changedFields, input.subject),
+            reversalKind: "none",
+        },
+    });
+}
+export async function listProductActionLedger(c) {
+    const productId = c.req.param("id");
+    if (!productId)
+        return c.json({ error: "Product not found" }, 404);
+    const product = await productsService.getProductById(c.get("db"), productId);
+    if (!product)
+        return c.json({ error: "Product not found" }, 404);
+    const query = parseQuery(c, productActionLedgerQuerySchema);
+    const limit = query.limit ?? 50;
+    const result = await actionLedgerService.listEntries(c.get("db"), {
+        targetType: "product",
+        targetId: product.id,
+        cursor: query.cursor,
+        limit: limit + 1,
+    });
+    const page = buildActionLedgerTargetTimelinePage({
+        entries: result.entries,
+        limit,
+    });
+    const details = await Promise.all(page.data.map((entry) => actionLedgerService.getEntry(c.get("db"), entry.id)));
+    const summariesByActionId = new Map(details.flatMap((detail) => detail ? [[detail.entry.id, detail.mutationDetail?.summary ?? null]] : []));
+    return c.json(buildActionLedgerTargetTimelinePage({
+        entries: result.entries,
+        limit,
+        mutationSummariesByActionId: summariesByActionId,
+    }));
+}
+function productValuesEqual(left, right) {
+    if (left instanceof Date || right instanceof Date) {
+        const leftTime = left instanceof Date ? left.getTime() : new Date(String(left)).getTime();
+        const rightTime = right instanceof Date ? right.getTime() : new Date(String(right)).getTime();
+        return leftTime === rightTime;
+    }
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+const ignoredMutationFields = new Set(["updatedAt", "createdAt"]);
+export const __test__ = {
+    changedMutationFields,
+    changedProductFields,
+    productMutationSummary,
+    productActionLedgerQuerySchema,
+};

package/dist/booking-extension.d.ts

@@ -244,9 +244,9 @@ export declare const bookingProductExtensionService: {
     upsertBookingDetails(db: PostgresJsDatabase, bookingId: string, data: z.infer<typeof bookingProductDetailSchema>): Promise<{
         createdAt: Date;
         updatedAt: Date;
-        bookingId: string;
         productId: string | null;
         optionId: string | null;
+        bookingId: string;
     } | null>;
     removeBookingDetails(db: PostgresJsDatabase, bookingId: string): Promise<{
         bookingId: string;
@@ -265,9 +265,9 @@ export declare const bookingProductExtensionService: {
         updatedAt: Date;
         productId: string | null;
         optionId: string | null;
-        bookingItemId: string;
-        unitId: string | null;
         supplierServiceId: string | null;
+        unitId: string | null;
+        bookingItemId: string;
     } | null>;
     removeItemDetails(db: PostgresJsDatabase, bookingItemId: string): Promise<{
         bookingItemId: string;

package/dist/catalog-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog-policy.d.ts","sourceRoot":"","sources":["../src/catalog-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAErF;;;GAGG;AACH,QAAA,MAAM,oBAAoB,EAAE,gBAAgB,EAshB3C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,2CAA0C,CAAA;AAE3E,OAAO,EAAE,oBAAoB,EAAE,CAAA"}
+{"version":3,"file":"catalog-policy.d.ts","sourceRoot":"","sources":["../src/catalog-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAErF;;;GAGG;AACH,QAAA,MAAM,oBAAoB,EAAE,gBAAgB,EAwiB3C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,2CAA0C,CAAA;AAE3E,OAAO,EAAE,oBAAoB,EAAE,CAAA"}

package/dist/catalog-policy.js

@@ -377,6 +377,24 @@ const PRODUCT_FIELD_POLICY = [
         overrideFriction: "none",
         sourceFreshness: "sync",
     },
+    {
+        path: "availableDeparturesCount",
+        class: "merchandisable",
+        merge: "source-only",
+        // High-drift because the count moves whenever availability_slots are
+        // added/removed or close-outs change; reindex-on-entry keeps it warm
+        // enough for the operator catalog table without being load-bearing
+        // for downstream booking flows.
+        drift: "high",
+        reindex: "facet-affecting",
+        snapshot: "never",
+        query: "indexed-column",
+        localized: false,
+        visibility: ["staff", "customer", "partner"],
+        editRole: "none",
+        overrideFriction: "none",
+        sourceFreshness: "sync",
+    },
     {
         path: "durationDays",
         class: "structural",

package/dist/content-shape.d.ts

@@ -77,6 +77,7 @@ export declare const productDaySchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hero_image_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     services: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
 export declare const productPolicySchema: z.ZodObject<{
@@ -150,6 +151,7 @@ export declare const productContentSchema: z.ZodObject<{
         title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         location: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        hero_image_url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         services: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
     }, z.core.$strip>>>;
     media: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/dist/content-shape.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"content-shape.d.ts","sourceRoot":"","sources":["../src/content-shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAE1B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;GAGG;AACH,eAAO,MAAM,+BAA+B,gBAAgB,CAAA;AAE5D;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAe/B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;iBAKjC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;iBAMlC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAM9B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;iBAM3B,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;iBAK9B,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAejC,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,GACf;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,cAAc,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAY7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,EACvC,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,gBAAgB,CAAM,GACzD,cAAc,CAchB"}
+{"version":3,"file":"content-shape.d.ts","sourceRoot":"","sources":["../src/content-shape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,oBAAoB,EAE1B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;GAGG;AACH,eAAO,MAAM,+BAA+B,gBAAgB,CAAA;AAE5D;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;iBAe/B,CAAA;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;iBAKjC,CAAA;AAEF,eAAO,MAAM,uBAAuB;;;;;;iBAMlC,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAM9B,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;iBAQ3B,CAAA;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;iBAK9B,CAAA;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;iBAejC,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AACrE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,OAAO,GACf;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,cAAc,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAY7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,aAAa,CAAC,cAAc,CAAC,EACvC,OAAO,GAAE,IAAI,CAAC,oBAAoB,EAAE,gBAAgB,CAAM,GACzD,cAAc,CAchB"}

package/dist/content-shape.js

@@ -67,6 +67,8 @@ export const productDaySchema = z.object({
     title: z.string().nullable().optional(),
     description: z.string().nullable().optional(),
     location: z.string().nullable().optional(),
+    /** Day-level hero image (catalog detail sheet thumbnail). */
+    hero_image_url: z.string().nullable().optional(),
     services: z.array(z.string()).optional().default([]),
 });
 export const productPolicySchema = z.object({