@voyant-travel/notifications 0.111.7

package/dist/service-booking-document-lifecycle.js

@@ -0,0 +1,259 @@
+import { bookings } from "@voyant-travel/bookings/schema";
+import { eq } from "drizzle-orm";
+import { bookingDocumentNotificationsService, } from "./service-booking-documents.js";
+import { listBookingNotificationItems, listBookingNotificationParticipants, resolveReminderRecipient, } from "./service-shared.js";
+export const BOOKING_FULLY_PAID_EVENT = "booking.fully-paid";
+function stageOptionsForTrigger(options, trigger) {
+    return trigger === BOOKING_FULLY_PAID_EVENT ? options.fullyPaid : options.confirmation;
+}
+function defaultDocumentTypesForTrigger(trigger) {
+    return trigger === BOOKING_FULLY_PAID_EVENT ? ["contract", "invoice"] : ["contract", "proforma"];
+}
+function getRequestedDocumentTypes(options, trigger) {
+    return (stageOptionsForTrigger(options, trigger)?.documentTypes ??
+        defaultDocumentTypesForTrigger(trigger));
+}
+function hasDocument(documents, documentType) {
+    return documents.some((document) => document.documentType === documentType);
+}
+function isFinanceDocumentType(documentType) {
+    return documentType === "invoice" || documentType === "proforma";
+}
+function messageFromError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function generatorStep(source, documentType, status, reason) {
+    return {
+        source,
+        documentType,
+        status,
+        ...(reason ? { reason } : {}),
+    };
+}
+export async function resolveBookingDocumentBundleLifecycleContext(db, input) {
+    const [booking] = await db
+        .select()
+        .from(bookings)
+        .where(eq(bookings.id, input.event.bookingId))
+        .limit(1);
+    if (!booking) {
+        return null;
+    }
+    const [bundle, travelers, items] = await Promise.all([
+        bookingDocumentNotificationsService.listBookingDocumentBundle(db, booking.id),
+        listBookingNotificationParticipants(db, booking.id),
+        listBookingNotificationItems(db, booking.id),
+    ]);
+    return {
+        trigger: input.trigger,
+        event: input.event,
+        booking,
+        customer: resolveReminderRecipient(booking, travelers),
+        travelers,
+        items,
+        existingDocuments: bundle?.documents ?? [],
+    };
+}
+export function createDefaultBookingDocumentBundlePolicy(options) {
+    return async (context, helpers) => {
+        const requestedTypes = getRequestedDocumentTypes(options, context.trigger);
+        const steps = [];
+        let documents = context.existingDocuments;
+        const missingTypes = requestedTypes.filter((documentType) => !hasDocument(documents, documentType));
+        const needsContract = missingTypes.includes("contract");
+        const financeTypes = missingTypes.filter(isFinanceDocumentType);
+        if (needsContract) {
+            if (helpers.ensureLegalDocuments) {
+                try {
+                    steps.push(...((await helpers.ensureLegalDocuments(context, {
+                        trigger: context.trigger,
+                        documentTypes: ["contract"],
+                    })) ?? [generatorStep("legal", "contract", "created")]));
+                    documents = await helpers.refreshDocuments();
+                }
+                catch (error) {
+                    return {
+                        status: "failed",
+                        bookingId: context.booking.id,
+                        steps: [
+                            ...steps,
+                            generatorStep("legal", "contract", "failed", messageFromError(error)),
+                        ],
+                        error: messageFromError(error),
+                    };
+                }
+            }
+            else {
+                steps.push(generatorStep("legal", "contract", "skipped", "no_generator"));
+            }
+        }
+        else if (requestedTypes.includes("contract")) {
+            steps.push(generatorStep("legal", "contract", "existing"));
+        }
+        for (const documentType of financeTypes) {
+            if (!helpers.ensureFinanceDocuments) {
+                steps.push(generatorStep("finance", documentType, "skipped", "no_generator"));
+                continue;
+            }
+            try {
+                steps.push(...((await helpers.ensureFinanceDocuments(context, {
+                    trigger: context.trigger,
+                    documentTypes: [documentType],
+                })) ?? [generatorStep("finance", documentType, "created")]));
+                documents = await helpers.refreshDocuments();
+            }
+            catch (error) {
+                return {
+                    status: "failed",
+                    bookingId: context.booking.id,
+                    steps: [
+                        ...steps,
+                        generatorStep("finance", documentType, "failed", messageFromError(error)),
+                    ],
+                    error: messageFromError(error),
+                };
+            }
+        }
+        for (const documentType of requestedTypes) {
+            if (isFinanceDocumentType(documentType) && !financeTypes.includes(documentType)) {
+                steps.push(generatorStep("finance", documentType, "existing"));
+            }
+        }
+        if (requestedTypes.includes("brochure")) {
+            if (helpers.resolveBrochureDocuments) {
+                try {
+                    const brochures = await helpers.resolveBrochureDocuments(context);
+                    documents = [...documents, ...brochures];
+                    steps.push({
+                        source: "products",
+                        documentType: "brochure",
+                        status: brochures.length > 0 ? "existing" : "skipped",
+                        ...(brochures.length === 0 ? { reason: "not_available" } : {}),
+                    });
+                }
+                catch (error) {
+                    return {
+                        status: "failed",
+                        bookingId: context.booking.id,
+                        steps: [
+                            ...steps,
+                            {
+                                source: "products",
+                                documentType: "brochure",
+                                status: "failed",
+                                reason: messageFromError(error),
+                            },
+                        ],
+                        error: messageFromError(error),
+                    };
+                }
+            }
+            else {
+                steps.push({
+                    source: "products",
+                    documentType: "brochure",
+                    status: "skipped",
+                    reason: "no_resolver",
+                });
+            }
+        }
+        return {
+            status: "ok",
+            bookingId: context.booking.id,
+            documents,
+            steps,
+        };
+    };
+}
+function defaultNotificationInput(options, context) {
+    const stage = stageOptionsForTrigger(options, context.trigger);
+    if (stage?.notification === false)
+        return false;
+    return {
+        ...(stage?.notification ?? {}),
+        documentTypes: stage?.notification && "documentTypes" in stage.notification
+            ? stage.notification.documentTypes
+            : getRequestedDocumentTypes(options, context.trigger),
+    };
+}
+export const bookingDocumentBundleLifecycleService = {
+    async run(db, dispatcher, input, options = {}, runtime = {}) {
+        const resolveContext = runtime.resolveContext ?? resolveBookingDocumentBundleLifecycleContext;
+        const context = await resolveContext(db, input);
+        if (!context) {
+            return { status: "not_found", bookingId: input.event.bookingId };
+        }
+        const helpers = {
+            refreshDocuments: async () => {
+                const bundle = await bookingDocumentNotificationsService.listBookingDocumentBundle(db, context.booking.id);
+                return bundle?.documents ?? [];
+            },
+            ensureLegalDocuments: options.ensureLegalDocuments,
+            ensureFinanceDocuments: options.ensureFinanceDocuments,
+            resolveBrochureDocuments: options.resolveBrochureDocuments,
+        };
+        let policyResult;
+        try {
+            const policy = options.policy ?? createDefaultBookingDocumentBundlePolicy(options);
+            policyResult = await policy(context, helpers);
+        }
+        catch (error) {
+            policyResult = {
+                status: "failed",
+                bookingId: context.booking.id,
+                steps: [{ source: "policy", status: "failed", reason: messageFromError(error) }],
+                error: messageFromError(error),
+            };
+        }
+        if (policyResult.status !== "ok") {
+            return policyResult;
+        }
+        let notificationInput;
+        try {
+            notificationInput =
+                options.notificationPolicy !== undefined
+                    ? await options.notificationPolicy(context, policyResult)
+                    : defaultNotificationInput(options, context);
+        }
+        catch (error) {
+            return {
+                status: "failed",
+                bookingId: context.booking.id,
+                steps: [
+                    ...policyResult.steps,
+                    { source: "notification", status: "failed", reason: messageFromError(error) },
+                ],
+                error: messageFromError(error),
+            };
+        }
+        if (notificationInput === false || notificationInput == null) {
+            return policyResult;
+        }
+        let notification;
+        try {
+            notification = await bookingDocumentNotificationsService.sendBookingDocumentsNotification(db, dispatcher, context.booking.id, notificationInput, { attachmentResolver: runtime.attachmentResolver, eventBus: runtime.eventBus });
+        }
+        catch (error) {
+            return {
+                status: "failed",
+                bookingId: context.booking.id,
+                steps: [
+                    ...policyResult.steps,
+                    { source: "notification", status: "failed", reason: messageFromError(error) },
+                ],
+                error: messageFromError(error),
+            };
+        }
+        return {
+            ...policyResult,
+            steps: [
+                ...policyResult.steps,
+                {
+                    source: "notification",
+                    status: notification.status === "sent" ? "sent" : "skipped",
+                    reason: notification.status === "sent" ? undefined : notification.status,
+                },
+            ],
+        };
+    },
+};

package/dist/service-booking-documents.d.ts

@@ -0,0 +1,256 @@
+import type { EventBus } from "@voyant-travel/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { BookingDocumentBundleItem, NotificationService, SendBookingDocumentsNotificationInput } from "./service-shared.js";
+import type { NotificationAttachment } from "./types.js";
+export type BookingDocumentAttachmentResolver = (document: BookingDocumentBundleItem) => Promise<NotificationAttachment | null>;
+export interface SendBookingDocumentsRuntimeOptions {
+    attachmentResolver?: BookingDocumentAttachmentResolver;
+    eventBus?: EventBus;
+}
+export interface BookingDocumentsSentEvent {
+    bookingId: string;
+    recipient: string;
+    deliveryId: string;
+    provider: string | null;
+    documentKeys: string[];
+}
+declare function createDefaultAttachmentFromDocument(document: BookingDocumentBundleItem): NotificationAttachment | null;
+export declare const bookingDocumentNotificationsService: {
+    listBookingDocumentBundle(db: PostgresJsDatabase, bookingId: string): Promise<{
+        bookingId: string;
+        documents: {
+            key: string;
+            source: "products" | "legal" | "finance";
+            documentType: "contract" | "invoice" | "proforma" | "brochure";
+            bookingId: string;
+            name: string;
+            createdAt: string;
+            contractId?: string | null | undefined;
+            invoiceId?: string | null | undefined;
+            attachmentId?: string | null | undefined;
+            renditionId?: string | null | undefined;
+            contractStatus?: string | null | undefined;
+            invoiceStatus?: string | null | undefined;
+            format?: string | null | undefined;
+            mimeType?: string | null | undefined;
+            storageKey?: string | null | undefined;
+            downloadUrl?: string | null | undefined;
+            language?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        }[];
+    } | null>;
+    sendBookingDocumentsNotification(db: PostgresJsDatabase, dispatcher: NotificationService, bookingId: string, input: SendBookingDocumentsNotificationInput, runtime?: SendBookingDocumentsRuntimeOptions): Promise<{
+        status: "not_found";
+        bookingId?: undefined;
+        recipient?: undefined;
+        documents?: undefined;
+        delivery?: undefined;
+    } | {
+        status: "no_documents";
+        bookingId?: undefined;
+        recipient?: undefined;
+        documents?: undefined;
+        delivery?: undefined;
+    } | {
+        status: "no_recipient";
+        bookingId?: undefined;
+        recipient?: undefined;
+        documents?: undefined;
+        delivery?: undefined;
+    } | {
+        status: "no_attachments";
+        bookingId?: undefined;
+        recipient?: undefined;
+        documents?: undefined;
+        delivery?: undefined;
+    } | {
+        status: "send_failed";
+        bookingId?: undefined;
+        recipient?: undefined;
+        documents?: undefined;
+        delivery?: undefined;
+    } | {
+        status: "sent";
+        bookingId: string;
+        recipient: string;
+        documents: {
+            key: string;
+            source: "products" | "legal" | "finance";
+            documentType: "contract" | "invoice" | "proforma" | "brochure";
+            bookingId: string;
+            name: string;
+            createdAt: string;
+            contractId?: string | null | undefined;
+            invoiceId?: string | null | undefined;
+            attachmentId?: string | null | undefined;
+            renditionId?: string | null | undefined;
+            contractStatus?: string | null | undefined;
+            invoiceStatus?: string | null | undefined;
+            format?: string | null | undefined;
+            mimeType?: string | null | undefined;
+            storageKey?: string | null | undefined;
+            downloadUrl?: string | null | undefined;
+            language?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        }[];
+        delivery: {
+            id: string;
+            templateId: string | null;
+            templateSlug: string | null;
+            targetType: "invoice" | "booking" | "booking_payment_schedule" | "booking_guarantee" | "payment_session" | "person" | "organization" | "other";
+            targetId: string | null;
+            personId: string | null;
+            organizationId: string | null;
+            bookingId: string | null;
+            invoiceId: string | null;
+            paymentSessionId: string | null;
+            channel: "email" | "sms";
+            provider: string;
+            providerMessageId: string | null;
+            status: "pending" | "sent" | "failed" | "cancelled";
+            toAddress: string;
+            fromAddress: string | null;
+            subject: string | null;
+            htmlBody: string | null;
+            textBody: string | null;
+            payloadData: Record<string, unknown> | null;
+            metadata: Record<string, unknown> | null;
+            errorMessage: string | null;
+            scheduledFor: Date | null;
+            sentAt: Date | null;
+            failedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+    }>;
+    /**
+     * Confirm-and-dispatch — single orchestrated call for the operator flow
+     * that wants "list the booking's documents, then send them to the client"
+     * to be one action instead of two round-trips.
+     *
+     * With `sendNotification: false`, the caller gets the bundle back without
+     * attempting a send — useful for rendering a preview/checkbox list before
+     * the operator confirms. With `sendNotification: true`, the same send
+     * guards as `sendBookingDocumentsNotification` apply (no_documents,
+     * no_recipient, no_attachments, send_failed); the result keeps the bundle
+     * regardless so the UI always has something to show.
+     */
+    confirmAndDispatchBooking(db: PostgresJsDatabase, dispatcher: NotificationService, bookingId: string, input: {
+        sendNotification?: boolean;
+    } & SendBookingDocumentsNotificationInput, runtime?: SendBookingDocumentsRuntimeOptions): Promise<{
+        status: "not_found";
+        bookingId?: undefined;
+        documents?: undefined;
+        skipReason?: undefined;
+        recipient?: undefined;
+        delivery?: undefined;
+    } | {
+        status: "preview";
+        bookingId: string;
+        documents: {
+            key: string;
+            source: "products" | "legal" | "finance";
+            documentType: "contract" | "invoice" | "proforma" | "brochure";
+            bookingId: string;
+            name: string;
+            createdAt: string;
+            contractId?: string | null | undefined;
+            invoiceId?: string | null | undefined;
+            attachmentId?: string | null | undefined;
+            renditionId?: string | null | undefined;
+            contractStatus?: string | null | undefined;
+            invoiceStatus?: string | null | undefined;
+            format?: string | null | undefined;
+            mimeType?: string | null | undefined;
+            storageKey?: string | null | undefined;
+            downloadUrl?: string | null | undefined;
+            language?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        }[];
+        skipReason?: undefined;
+        recipient?: undefined;
+        delivery?: undefined;
+    } | {
+        status: "skipped";
+        bookingId: string;
+        documents: {
+            key: string;
+            source: "products" | "legal" | "finance";
+            documentType: "contract" | "invoice" | "proforma" | "brochure";
+            bookingId: string;
+            name: string;
+            createdAt: string;
+            contractId?: string | null | undefined;
+            invoiceId?: string | null | undefined;
+            attachmentId?: string | null | undefined;
+            renditionId?: string | null | undefined;
+            contractStatus?: string | null | undefined;
+            invoiceStatus?: string | null | undefined;
+            format?: string | null | undefined;
+            mimeType?: string | null | undefined;
+            storageKey?: string | null | undefined;
+            downloadUrl?: string | null | undefined;
+            language?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        }[];
+        skipReason: "no_documents" | "no_recipient" | "no_attachments" | "send_failed";
+        recipient?: undefined;
+        delivery?: undefined;
+    } | {
+        status: "dispatched";
+        bookingId: string;
+        documents: {
+            key: string;
+            source: "products" | "legal" | "finance";
+            documentType: "contract" | "invoice" | "proforma" | "brochure";
+            bookingId: string;
+            name: string;
+            createdAt: string;
+            contractId?: string | null | undefined;
+            invoiceId?: string | null | undefined;
+            attachmentId?: string | null | undefined;
+            renditionId?: string | null | undefined;
+            contractStatus?: string | null | undefined;
+            invoiceStatus?: string | null | undefined;
+            format?: string | null | undefined;
+            mimeType?: string | null | undefined;
+            storageKey?: string | null | undefined;
+            downloadUrl?: string | null | undefined;
+            language?: string | null | undefined;
+            metadata?: Record<string, unknown> | null | undefined;
+        }[];
+        recipient: string;
+        delivery: {
+            id: string;
+            templateId: string | null;
+            templateSlug: string | null;
+            targetType: "invoice" | "booking" | "booking_payment_schedule" | "booking_guarantee" | "payment_session" | "person" | "organization" | "other";
+            targetId: string | null;
+            personId: string | null;
+            organizationId: string | null;
+            bookingId: string | null;
+            invoiceId: string | null;
+            paymentSessionId: string | null;
+            channel: "email" | "sms";
+            provider: string;
+            providerMessageId: string | null;
+            status: "pending" | "sent" | "failed" | "cancelled";
+            toAddress: string;
+            fromAddress: string | null;
+            subject: string | null;
+            htmlBody: string | null;
+            textBody: string | null;
+            payloadData: Record<string, unknown> | null;
+            metadata: Record<string, unknown> | null;
+            errorMessage: string | null;
+            scheduledFor: Date | null;
+            sentAt: Date | null;
+            failedAt: Date | null;
+            createdAt: Date;
+            updatedAt: Date;
+        };
+        skipReason?: undefined;
+    }>;
+};
+export { createDefaultAttachmentFromDocument as createDefaultBookingDocumentAttachment };
+//# sourceMappingURL=service-booking-documents.d.ts.map

package/dist/service-booking-documents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-booking-documents.d.ts","sourceRoot":"","sources":["../src/service-booking-documents.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAInD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,KAAK,EACV,yBAAyB,EACzB,mBAAmB,EACnB,qCAAqC,EACtC,MAAM,qBAAqB,CAAA;AAM5B,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAExD,MAAM,MAAM,iCAAiC,GAAG,CAC9C,QAAQ,EAAE,yBAAyB,KAChC,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAA;AAE3C,MAAM,WAAW,kCAAkC;IACjD,kBAAkB,CAAC,EAAE,iCAAiC,CAAA;IACtD,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACpB;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,YAAY,EAAE,MAAM,EAAE,CAAA;CACvB;AA2BD,iBAAS,mCAAmC,CAC1C,QAAQ,EAAE,yBAAyB,GAClC,sBAAsB,GAAG,IAAI,CAU/B;AAwLD,eAAO,MAAM,mCAAmC;kCACV,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;yCAkBnE,kBAAkB,cACV,mBAAmB,aACpB,MAAM,SACV,qCAAqC,YACnC,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoH7C;;;;;;;;;;;OAWG;kCAEG,kBAAkB,cACV,mBAAmB,aACpB,MAAM,SACV;QAAE,gBAAgB,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,qCAAqC,YACpE,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C9C,CAAA;AAED,OAAO,EAAE,mCAAmC,IAAI,sCAAsC,EAAE,CAAA"}