@voyantjs/products 0.52.2 → 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/events.d.ts

@@ -19,7 +19,7 @@ export interface ProductContentChangedEvent {
      * push hashes the full current content at push time so this field is
      * not load-bearing for correctness.
      */
-    axis?: "product" | "option" | "day" | "media" | "feature" | "faq" | "location" | "destination" | "category" | "tag" | "translation";
+    axis?: "product" | "itinerary" | "option" | "day" | "media" | "feature" | "faq" | "location" | "destination" | "category" | "tag" | "translation";
 }
 /**
  * Helper for route handlers / services to fire `product.content.changed`

package/dist/events.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C,+BAA+B;AAC/B,eAAO,MAAM,6BAA6B,EAAG,yBAAkC,CAAA;AAE/E,MAAM,WAAW,0BAA0B;IACzC,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAA;IACV;;;;OAIG;IACH,IAAI,CAAC,EACD,SAAS,GACT,QAAQ,GACR,KAAK,GACL,OAAO,GACP,SAAS,GACT,KAAK,GACL,UAAU,GACV,aAAa,GACb,UAAU,GACV,KAAK,GACL,aAAa,CAAA;CAClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAC9B,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,IAAI,CAAC,CAMf"}
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAE9C,+BAA+B;AAC/B,eAAO,MAAM,6BAA6B,EAAG,yBAAkC,CAAA;AAE/E,MAAM,WAAW,0BAA0B;IACzC,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAA;IACV;;;;OAIG;IACH,IAAI,CAAC,EACD,SAAS,GACT,WAAW,GACX,QAAQ,GACR,KAAK,GACL,OAAO,GACP,SAAS,GACT,KAAK,GACL,UAAU,GACV,aAAa,GACb,UAAU,GACV,KAAK,GACL,aAAa,CAAA;CAClB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAC9B,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/route-env.d.ts

@@ -0,0 +1,22 @@
+import type { EventBus } from "@voyantjs/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+export type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+        agentId?: string;
+        workflowPrincipalId?: string;
+        principalSubtype?: string;
+        sessionId?: string;
+        apiTokenId?: string;
+        apiKeyId?: string;
+        callerType?: string;
+        actor?: string;
+        isInternalRequest?: boolean;
+        organizationId?: string;
+        workflowRunId?: string;
+        workflowStepId?: string;
+        eventBus?: EventBus;
+    };
+};
+//# sourceMappingURL=route-env.d.ts.map

package/dist/route-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route-env.d.ts","sourceRoot":"","sources":["../src/route-env.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,MAAM,MAAM,GAAG,GAAG;IAChB,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,mBAAmB,CAAC,EAAE,MAAM,CAAA;QAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAA;QACzB,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,UAAU,CAAC,EAAE,MAAM,CAAA;QACnB,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,iBAAiB,CAAC,EAAE,OAAO,CAAA;QAC3B,cAAc,CAAC,EAAE,MAAM,CAAA;QACvB,aAAa,CAAC,EAAE,MAAM,CAAA;QACtB,cAAc,CAAC,EAAE,MAAM,CAAA;QACvB,QAAQ,CAAC,EAAE,QAAQ,CAAA;KACpB,CAAA;CACF,CAAA"}

package/dist/route-env.js

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