@voyant-travel/bookings 0.119.3

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

@@ -0,0 +1,30 @@
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import type { BookingActionLedgerDriftCheck, CheckBookingActionLedgerDriftInput, CheckBookingActionLedgerDriftResult } from "./action-ledger-drift.js";
+export interface BookingActionLedgerDriftRemediationItem {
+    check: BookingActionLedgerDriftCheck;
+    missingCount: number;
+    sampleTargetIds: string[];
+    sampleTruncated: boolean;
+    recommendedBackfillActionName: string;
+    targetType: string;
+    targetIdKind: string;
+    mode: "dry_run";
+    note: string;
+}
+export interface BookingActionLedgerDriftRemediationPlan {
+    mode: "dry_run";
+    generatedAt: string;
+    createdAtFrom: string | null;
+    sampleLimit: number | null;
+    totalMissingCount: number;
+    items: BookingActionLedgerDriftRemediationItem[];
+}
+export interface BuildBookingActionLedgerDriftRemediationPlanInput {
+    drift: CheckBookingActionLedgerDriftResult;
+    createdAtFrom?: CheckBookingActionLedgerDriftInput["createdAtFrom"];
+    sampleLimit?: number | null;
+    generatedAt?: Date | string;
+}
+export declare function planBookingActionLedgerDriftRemediation(db: AnyDrizzleDb, input?: CheckBookingActionLedgerDriftInput): Promise<BookingActionLedgerDriftRemediationPlan>;
+export declare function buildBookingActionLedgerDriftRemediationPlan({ drift, createdAtFrom, sampleLimit, generatedAt, }: BuildBookingActionLedgerDriftRemediationPlanInput): BookingActionLedgerDriftRemediationPlan;
+//# sourceMappingURL=action-ledger-drift-remediation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"action-ledger-drift-remediation.d.ts","sourceRoot":"","sources":["../src/action-ledger-drift-remediation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EACV,6BAA6B,EAC7B,kCAAkC,EAClC,mCAAmC,EACpC,MAAM,0BAA0B,CAAA;AAgDjC,MAAM,WAAW,uCAAuC;IACtD,KAAK,EAAE,6BAA6B,CAAA;IACpC,YAAY,EAAE,MAAM,CAAA;IACpB,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,eAAe,EAAE,OAAO,CAAA;IACxB,6BAA6B,EAAE,MAAM,CAAA;IACrC,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,uCAAuC;IACtD,IAAI,EAAE,SAAS,CAAA;IACf,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,iBAAiB,EAAE,MAAM,CAAA;IACzB,KAAK,EAAE,uCAAuC,EAAE,CAAA;CACjD;AAED,MAAM,WAAW,iDAAiD;IAChE,KAAK,EAAE,mCAAmC,CAAA;IAC1C,aAAa,CAAC,EAAE,kCAAkC,CAAC,eAAe,CAAC,CAAA;IACnE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,WAAW,CAAC,EAAE,IAAI,GAAG,MAAM,CAAA;CAC5B;AAED,wBAAsB,uCAAuC,CAC3D,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,kCAAuC,GAC7C,OAAO,CAAC,uCAAuC,CAAC,CAOlD;AAED,wBAAgB,4CAA4C,CAAC,EAC3D,KAAK,EACL,aAAa,EACb,WAAW,EACX,WAAwB,GACzB,EAAE,iDAAiD,GAAG,uCAAuC,CA+B7F"}

package/dist/action-ledger-drift-remediation.js

@@ -0,0 +1,85 @@
+import { checkBookingActionLedgerDrift } from "./action-ledger-drift.js";
+const BACKFILL_ACTION_BY_CHECK = {
+    booking_confirmed: {
+        actionName: "booking.status.confirm",
+        targetType: "booking",
+        targetIdKind: "booking_id",
+    },
+    booking_expired: {
+        actionName: "booking.status.expire",
+        targetType: "booking",
+        targetIdKind: "booking_id",
+    },
+    booking_cancelled: {
+        actionName: "booking.status.cancel",
+        targetType: "booking",
+        targetIdKind: "booking_id",
+    },
+    booking_completed: {
+        actionName: "booking.status.complete",
+        targetType: "booking",
+        targetIdKind: "booking_id",
+    },
+    booking_item: {
+        actionName: "booking.item.create",
+        targetType: "booking_item",
+        targetIdKind: "booking_item_id",
+    },
+    booking_traveler: {
+        actionName: "booking.traveler.create",
+        targetType: "booking_traveler",
+        targetIdKind: "booking_traveler_id",
+    },
+    booking_traveler_travel_details: {
+        actionName: "booking.traveler_travel_details.update",
+        targetType: "booking_traveler",
+        targetIdKind: "booking_traveler_id",
+    },
+};
+export async function planBookingActionLedgerDriftRemediation(db, input = {}) {
+    const drift = await checkBookingActionLedgerDrift(db, input);
+    return buildBookingActionLedgerDriftRemediationPlan({
+        drift,
+        createdAtFrom: input.createdAtFrom,
+        sampleLimit: input.sampleLimit,
+    });
+}
+export function buildBookingActionLedgerDriftRemediationPlan({ drift, createdAtFrom, sampleLimit, generatedAt = new Date(), }) {
+    const generatedAtDate = generatedAt instanceof Date ? generatedAt : new Date(generatedAt);
+    if (Number.isNaN(generatedAtDate.getTime())) {
+        throw new Error("generatedAt must be a valid date");
+    }
+    const items = drift.rows
+        .filter((row) => row.missingCount > 0)
+        .map((row) => {
+        const action = BACKFILL_ACTION_BY_CHECK[row.check];
+        return {
+            check: row.check,
+            missingCount: row.missingCount,
+            sampleTargetIds: row.sampleIds,
+            sampleTruncated: row.missingCount > row.sampleIds.length,
+            recommendedBackfillActionName: action.actionName,
+            targetType: action.targetType,
+            targetIdKind: action.targetIdKind,
+            mode: "dry_run",
+            note: "Dry run only. Review source rows and choose an explicit historical actor before writing backfill ledger entries.",
+        };
+    });
+    return {
+        mode: "dry_run",
+        generatedAt: generatedAtDate.toISOString(),
+        createdAtFrom: normalizeNullableDate(createdAtFrom),
+        sampleLimit: sampleLimit ?? null,
+        totalMissingCount: items.reduce((sum, item) => sum + item.missingCount, 0),
+        items,
+    };
+}
+function normalizeNullableDate(value) {
+    if (!value)
+        return null;
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        throw new Error("createdAtFrom must be a valid date");
+    }
+    return date.toISOString();
+}

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

@@ -0,0 +1,29 @@
+import type { AnyDrizzleDb } from "@voyant-travel/db";
+import { type SQL } from "drizzle-orm";
+export type BookingActionLedgerDriftCheck = "booking_confirmed" | "booking_expired" | "booking_cancelled" | "booking_completed" | "booking_item" | "booking_traveler" | "booking_traveler_travel_details";
+export interface CheckBookingActionLedgerDriftInput {
+    createdAtFrom?: Date | string | null;
+    sampleLimit?: number | null;
+}
+export interface BookingActionLedgerDriftRow {
+    check: BookingActionLedgerDriftCheck;
+    missingCount: number;
+    sampleIds: string[];
+}
+export interface CheckBookingActionLedgerDriftResult {
+    ok: boolean;
+    rows: BookingActionLedgerDriftRow[];
+}
+interface BookingActionLedgerDriftQueryRow extends Record<string, unknown> {
+    check: BookingActionLedgerDriftCheck;
+    missing_count: number | string;
+    sample_ids: string[] | null;
+}
+export declare function buildBookingActionLedgerDriftQueries(input?: CheckBookingActionLedgerDriftInput): Record<BookingActionLedgerDriftCheck, SQL<BookingActionLedgerDriftQueryRow>>;
+export declare function checkBookingActionLedgerDrift(db: AnyDrizzleDb, input?: CheckBookingActionLedgerDriftInput): Promise<CheckBookingActionLedgerDriftResult>;
+declare function normalizeRow(row: BookingActionLedgerDriftQueryRow): BookingActionLedgerDriftRow;
+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,mBAAmB,CAAA;AACrD,OAAO,EAAE,KAAK,GAAG,EAAwB,MAAM,aAAa,CAAA;AAsB5D,MAAM,MAAM,6BAA6B,GACrC,mBAAmB,GACnB,iBAAiB,GACjB,mBAAmB,GACnB,mBAAmB,GACnB,cAAc,GACd,kBAAkB,GAClB,iCAAiC,CAAA;AAErC,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,CA8H9E;AAED,wBAAsB,6BAA6B,CACjD,EAAE,EAAE,YAAY,EAChB,KAAK,GAAE,kCAAuC,GAC7C,OAAO,CAAC,mCAAmC,CAAC,CAmB9C;AA+DD,iBAAS,YAAY,CAAC,GAAG,EAAE,gCAAgC,GAAG,2BAA2B,CAMxF;AAED,eAAO,MAAM,QAAQ;;CAEpB,CAAA"}

package/dist/action-ledger-drift.js

@@ -0,0 +1,222 @@
+import { actionLedgerEntries } from "@voyant-travel/action-ledger/schema";
+import { sql } from "drizzle-orm";
+import { bookingTravelerTravelDetails } from "./schema/travel-details.js";
+import { bookings, bookingTravelers } from "./schema-core.js";
+import { bookingItems } from "./schema-items.js";
+const DEFAULT_SAMPLE_LIMIT = 20;
+const MAX_SAMPLE_LIMIT = 100;
+const BOOKING_CONFIRM_ACTION_NAME = "booking.status.confirm";
+const BOOKING_EXPIRE_ACTION_NAME = "booking.status.expire";
+const BOOKING_CANCEL_ACTION_NAME = "booking.status.cancel";
+const BOOKING_COMPLETE_ACTION_NAME = "booking.status.complete";
+const BOOKING_TRAVELER_CREATE_ACTION_NAMES = [
+    "booking.traveler.create",
+    "booking.traveler_with_travel_details.create",
+];
+const BOOKING_TRAVELER_TRAVEL_DETAILS_ACTION_NAMES = [
+    "booking.traveler_with_travel_details.create",
+    "booking.traveler_travel_details.update",
+];
+const BOOKING_ITEM_CREATE_ACTION_NAME = "booking.item.create";
+export function buildBookingActionLedgerDriftQueries(input = {}) {
+    const sampleLimit = normalizeSampleLimit(input.sampleLimit);
+    return {
+        booking_confirmed: buildBookingStatusDriftQuery({
+            check: "booking_confirmed",
+            actionName: BOOKING_CONFIRM_ACTION_NAME,
+            timestampColumn: bookings.confirmedAt,
+            input,
+            sampleLimit,
+        }),
+        booking_expired: buildBookingStatusDriftQuery({
+            check: "booking_expired",
+            actionName: BOOKING_EXPIRE_ACTION_NAME,
+            timestampColumn: bookings.expiredAt,
+            input,
+            sampleLimit,
+        }),
+        booking_cancelled: buildBookingStatusDriftQuery({
+            check: "booking_cancelled",
+            actionName: BOOKING_CANCEL_ACTION_NAME,
+            timestampColumn: bookings.cancelledAt,
+            input,
+            sampleLimit,
+        }),
+        booking_completed: buildBookingStatusDriftQuery({
+            check: "booking_completed",
+            actionName: BOOKING_COMPLETE_ACTION_NAME,
+            timestampColumn: bookings.completedAt,
+            input,
+            sampleLimit,
+        }),
+        booking_item: sql `
+      SELECT
+        'booking_item' 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
+          ${bookingItems.id} AS candidate_id,
+          ${bookingItems.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${bookingItems.createdAt} DESC, ${bookingItems.id} DESC
+          ) AS sample_ordinal
+        FROM ${bookingItems}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(bookingItems.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} = ${BOOKING_ITEM_CREATE_ACTION_NAME}
+              AND ${actionLedgerEntries.targetType} = ${"booking_item"}
+              AND ${actionLedgerEntries.targetId} = ${bookingItems.id}
+          )
+      ) missing
+    `,
+        booking_traveler: sql `
+      SELECT
+        'booking_traveler' 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
+          ${bookingTravelers.id} AS candidate_id,
+          ${bookingTravelers.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${bookingTravelers.createdAt} DESC, ${bookingTravelers.id} DESC
+          ) AS sample_ordinal
+        FROM ${bookingTravelers}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(bookingTravelers.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} IN (${sql.join(
+        // agent-quality: raw-sql reviewed -- owner: bookings; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        BOOKING_TRAVELER_CREATE_ACTION_NAMES.map((actionName) => sql `${actionName}`), sql `, `)})
+              AND ${actionLedgerEntries.targetType} = ${"booking_traveler"}
+              AND ${actionLedgerEntries.targetId} = ${bookingTravelers.id}
+          )
+      ) missing
+    `,
+        booking_traveler_travel_details: sql `
+      SELECT
+        'booking_traveler_travel_details' 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
+          ${bookingTravelerTravelDetails.travelerId} AS candidate_id,
+          ${bookingTravelerTravelDetails.createdAt} AS created_at,
+          row_number() OVER (
+            ORDER BY ${bookingTravelerTravelDetails.createdAt} DESC,
+              ${bookingTravelerTravelDetails.travelerId} DESC
+          ) AS sample_ordinal
+        FROM ${bookingTravelerTravelDetails}
+        WHERE 1 = 1
+          ${buildCreatedAtCondition(bookingTravelerTravelDetails.createdAt, input.createdAtFrom)}
+          AND NOT EXISTS (
+            SELECT 1
+            FROM ${actionLedgerEntries}
+            WHERE ${actionLedgerEntries.actionName} IN (${sql.join(
+        // agent-quality: raw-sql reviewed -- owner: bookings; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+        BOOKING_TRAVELER_TRAVEL_DETAILS_ACTION_NAMES.map((actionName) => sql `${actionName}`), sql `, `)})
+              AND ${actionLedgerEntries.targetType} = ${"booking_traveler"}
+              AND ${actionLedgerEntries.targetId} = ${bookingTravelerTravelDetails.travelerId}
+          )
+      ) missing
+    `,
+    };
+}
+export async function checkBookingActionLedgerDrift(db, input = {}) {
+    const queries = buildBookingActionLedgerDriftQueries(input);
+    const results = await Promise.all([
+        db.execute(queries.booking_confirmed),
+        db.execute(queries.booking_expired),
+        db.execute(queries.booking_cancelled),
+        db.execute(queries.booking_completed),
+        db.execute(queries.booking_item),
+        db.execute(queries.booking_traveler),
+        db.execute(queries.booking_traveler_travel_details),
+    ]);
+    const rows = results
+        .flatMap((result) => extractRows(result))
+        .map((row) => normalizeRow(row));
+    return {
+        ok: rows.every((row) => row.missingCount === 0),
+        rows,
+    };
+}
+function buildBookingStatusDriftQuery(input) {
+    return sql `
+    SELECT
+      ${input.check} AS check,
+      count(*)::int AS missing_count,
+      coalesce(
+        array_agg(candidate_id ORDER BY created_at DESC, candidate_id DESC)
+          FILTER (WHERE sample_ordinal <= ${input.sampleLimit}),
+        ARRAY[]::text[]
+      ) AS sample_ids
+    FROM (
+      SELECT
+        ${bookings.id} AS candidate_id,
+        ${input.timestampColumn} AS created_at,
+        row_number() OVER (
+          ORDER BY ${input.timestampColumn} DESC, ${bookings.id} DESC
+        ) AS sample_ordinal
+      FROM ${bookings}
+      WHERE ${input.timestampColumn} IS NOT NULL
+        ${buildCreatedAtCondition(input.timestampColumn, input.input.createdAtFrom)}
+        AND NOT EXISTS (
+          SELECT 1
+          FROM ${actionLedgerEntries}
+          WHERE ${actionLedgerEntries.actionName} = ${input.actionName}
+            AND ${actionLedgerEntries.targetType} = ${"booking"}
+            AND ${actionLedgerEntries.targetId} = ${bookings.id}
+        )
+    ) missing
+  `;
+}
+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");
+    }
+    // agent-quality: raw-sql reviewed -- owner: bookings; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    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,
+};