@voyant-travel/notifications 0.111.7

package/dist/service-reminder-events.js

@@ -0,0 +1,178 @@
+import { bookings, bookingTravelers } from "@voyant-travel/bookings/schema";
+import { and, desc, eq } from "drizzle-orm";
+import { notificationReminderRules, notificationReminderRuns } from "./schema.js";
+import { sendNotification } from "./service-deliveries.js";
+import { getBookingEventDocumentContext, getBookingPaymentNotificationContext, hasOutstandingBookingBalance, serializeBookingPaymentContext, } from "./service-reminder-booking-context.js";
+import { markReminderRunFailed, markReminderRunSent, markReminderRunSkipped, } from "./service-reminder-run-state.js";
+import { buildReminderDedupeKey, listBookingNotificationItems, resolveReminderRecipient, } from "./service-shared.js";
+async function sendBookingEventReminder(db, dispatcher, rule, input, runtime = {}) {
+    const now = new Date();
+    const dedupeKey = buildReminderDedupeKey(rule.id, input.bookingId, input.targetType);
+    const [existingRun] = await db
+        .select({ id: notificationReminderRuns.id })
+        .from(notificationReminderRuns)
+        .where(eq(notificationReminderRuns.dedupeKey, dedupeKey))
+        .limit(1);
+    if (existingRun) {
+        return null;
+    }
+    const [booking] = await db
+        .select()
+        .from(bookings)
+        .where(eq(bookings.id, input.bookingId))
+        .limit(1);
+    if (!booking) {
+        const [run] = await db
+            .insert(notificationReminderRuns)
+            .values({
+            reminderRuleId: rule.id,
+            targetType: input.targetType,
+            targetId: input.bookingId,
+            dedupeKey,
+            bookingId: input.bookingId,
+            personId: null,
+            organizationId: null,
+            paymentSessionId: input.paymentSessionId ?? null,
+            notificationDeliveryId: null,
+            status: "skipped",
+            recipient: null,
+            scheduledFor: now,
+            processedAt: now,
+            errorMessage: "Booking not found for notification event",
+            metadata: {
+                eventTargetType: input.targetType,
+                ...(input.eventData ?? {}),
+            },
+        })
+            .returning();
+        return run ?? null;
+    }
+    const [participants, items, paymentContext, documentContext] = await Promise.all([
+        db
+            .select({
+            id: bookingTravelers.id,
+            firstName: bookingTravelers.firstName,
+            lastName: bookingTravelers.lastName,
+            email: bookingTravelers.email,
+            participantType: bookingTravelers.participantType,
+            isPrimary: bookingTravelers.isPrimary,
+        })
+            .from(bookingTravelers)
+            .where(eq(bookingTravelers.bookingId, booking.id))
+            .orderBy(desc(bookingTravelers.isPrimary), bookingTravelers.createdAt),
+        listBookingNotificationItems(db, booking.id),
+        getBookingPaymentNotificationContext(db, booking.id),
+        input.targetType === "booking_confirmed" && rule.channel === "email"
+            ? getBookingEventDocumentContext(db, booking.id, runtime.documentAttachmentResolver)
+            : Promise.resolve({ documents: [], attachments: [] }),
+    ]);
+    const recipient = resolveReminderRecipient(booking, participants);
+    const [processingRun] = await db
+        .insert(notificationReminderRuns)
+        .values({
+        reminderRuleId: rule.id,
+        targetType: input.targetType,
+        targetId: booking.id,
+        dedupeKey,
+        bookingId: booking.id,
+        personId: booking.personId ?? null,
+        organizationId: booking.organizationId ?? null,
+        paymentSessionId: input.paymentSessionId ?? null,
+        notificationDeliveryId: null,
+        status: "processing",
+        recipient: recipient?.email ?? null,
+        scheduledFor: now,
+        processedAt: now,
+        errorMessage: null,
+        metadata: {
+            eventTargetType: input.targetType,
+            bookingNumber: booking.bookingNumber,
+            ...(input.eventData ?? {}),
+        },
+    })
+        .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
+        .returning();
+    if (!processingRun) {
+        return null;
+    }
+    if (!recipient?.email) {
+        return markReminderRunSkipped(db, processingRun.id, now, "No traveler email available for booking notification event");
+    }
+    try {
+        const delivery = await sendNotification(db, dispatcher, {
+            templateId: rule.templateId ?? null,
+            templateSlug: rule.templateSlug ?? null,
+            channel: rule.channel,
+            provider: rule.provider ?? null,
+            to: recipient.email,
+            data: {
+                bookingId: booking.id,
+                bookingNumber: booking.bookingNumber,
+                trigger: input.targetType,
+                event: input.eventData ?? {},
+                traveler: {
+                    firstName: recipient.firstName,
+                    lastName: recipient.lastName,
+                    email: recipient.email,
+                    participantType: recipient.participantType,
+                    isPrimary: recipient.isPrimary,
+                },
+                travelers: participants,
+                booking: {
+                    id: booking.id,
+                    bookingNumber: booking.bookingNumber,
+                    status: booking.status,
+                    startDate: booking.startDate,
+                    endDate: booking.endDate,
+                    sellCurrency: booking.sellCurrency,
+                    sellAmountCents: booking.sellAmountCents,
+                },
+                ...serializeBookingPaymentContext(paymentContext),
+                payment: input.targetType === "payment_complete"
+                    ? {
+                        isPaidInFull: true,
+                        paymentSessionId: input.paymentSessionId ?? null,
+                    }
+                    : null,
+                documents: documentContext.documents,
+                items,
+            },
+            attachments: documentContext.attachments.length > 0 ? documentContext.attachments : null,
+            targetType: input.targetType === "payment_complete" ? "payment_session" : "booking",
+            targetId: input.targetType === "payment_complete"
+                ? (input.paymentSessionId ?? booking.id)
+                : booking.id,
+            bookingId: booking.id,
+            paymentSessionId: input.paymentSessionId ?? null,
+            personId: booking.personId ?? null,
+            organizationId: booking.organizationId ?? null,
+            metadata: {
+                reminderRuleId: rule.id,
+                reminderRunId: processingRun.id,
+                eventTargetType: input.targetType,
+                bookingDocumentKeys: documentContext.documents.map((document) => document.key),
+            },
+            scheduledFor: now.toISOString(),
+        });
+        return markReminderRunSent(db, processingRun.id, new Date(), delivery?.id ?? null);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Notification event delivery failed";
+        return markReminderRunFailed(db, processingRun.id, new Date(), message);
+    }
+}
+export async function dispatchReminderEventRules(db, dispatcher, input, runtime = {}) {
+    const rules = await db
+        .select()
+        .from(notificationReminderRules)
+        .where(and(eq(notificationReminderRules.status, "active"), eq(notificationReminderRules.targetType, input.targetType)))
+        .orderBy(notificationReminderRules.createdAt);
+    const results = [];
+    for (const rule of rules) {
+        results.push(await sendBookingEventReminder(db, dispatcher, rule, input, runtime));
+    }
+    return results;
+}
+export async function bookingIsPaidInFullForNotification(db, bookingId) {
+    return !(await hasOutstandingBookingBalance(db, bookingId));
+}

package/dist/service-reminder-run-state.d.ts

@@ -0,0 +1,114 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { notificationReminderRuns } from "./schema.js";
+import type { NotificationReminderRuleRow, ReminderQueueResult, ReminderSweepResult } from "./service-shared.js";
+export type ReminderDeliveryEnqueuer = (input: {
+    reminderRunId: string;
+}) => Promise<void>;
+export type NotificationReminderRunRow = typeof notificationReminderRuns.$inferSelect;
+export declare function buildReminderSweepSummary(): ReminderSweepResult;
+export declare function buildReminderQueueSummary(): ReminderQueueResult;
+export declare function getReminderRuleById(db: PostgresJsDatabase, reminderRuleId: string): Promise<{
+    id: string;
+    slug: string;
+    name: string;
+    status: "draft" | "active" | "archived";
+    targetType: "invoice" | "booking_payment_schedule" | "booking_confirmed" | "payment_complete" | "booking_cancelled_non_payment";
+    channel: "email" | "sms";
+    provider: string | null;
+    templateId: string | null;
+    templateSlug: string | null;
+    priority: number;
+    suppressionGroup: string | null;
+    isSystem: boolean;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function getReminderRunById(db: PostgresJsDatabase, reminderRunId: string): Promise<{
+    id: string;
+    reminderRuleId: string;
+    targetType: "invoice" | "booking_payment_schedule" | "booking_confirmed" | "payment_complete" | "booking_cancelled_non_payment";
+    targetId: string;
+    dedupeKey: string;
+    bookingId: string | null;
+    personId: string | null;
+    organizationId: string | null;
+    paymentSessionId: string | null;
+    notificationDeliveryId: string | null;
+    status: "sent" | "failed" | "queued" | "processing" | "skipped";
+    recipient: string | null;
+    scheduledFor: Date;
+    processedAt: Date;
+    errorMessage: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function markReminderRunSkipped(db: PostgresJsDatabase, reminderRunId: string, now: Date, errorMessage: string): Promise<{
+    id: string;
+    reminderRuleId: string;
+    targetType: "invoice" | "booking_payment_schedule" | "booking_confirmed" | "payment_complete" | "booking_cancelled_non_payment";
+    targetId: string;
+    dedupeKey: string;
+    bookingId: string | null;
+    personId: string | null;
+    organizationId: string | null;
+    paymentSessionId: string | null;
+    notificationDeliveryId: string | null;
+    status: "sent" | "failed" | "queued" | "processing" | "skipped";
+    recipient: string | null;
+    scheduledFor: Date;
+    processedAt: Date;
+    errorMessage: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function markReminderRunFailed(db: PostgresJsDatabase, reminderRunId: string, now: Date, errorMessage: string): Promise<{
+    id: string;
+    reminderRuleId: string;
+    targetType: "invoice" | "booking_payment_schedule" | "booking_confirmed" | "payment_complete" | "booking_cancelled_non_payment";
+    targetId: string;
+    dedupeKey: string;
+    bookingId: string | null;
+    personId: string | null;
+    organizationId: string | null;
+    paymentSessionId: string | null;
+    notificationDeliveryId: string | null;
+    status: "sent" | "failed" | "queued" | "processing" | "skipped";
+    recipient: string | null;
+    scheduledFor: Date;
+    processedAt: Date;
+    errorMessage: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export declare function markReminderRunSent(db: PostgresJsDatabase, reminderRunId: string, now: Date, notificationDeliveryId: string | null): Promise<{
+    id: string;
+    reminderRuleId: string;
+    targetType: "invoice" | "booking_payment_schedule" | "booking_confirmed" | "payment_complete" | "booking_cancelled_non_payment";
+    targetId: string;
+    dedupeKey: string;
+    bookingId: string | null;
+    personId: string | null;
+    organizationId: string | null;
+    paymentSessionId: string | null;
+    notificationDeliveryId: string | null;
+    status: "sent" | "failed" | "queued" | "processing" | "skipped";
+    recipient: string | null;
+    scheduledFor: Date;
+    processedAt: Date;
+    errorMessage: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+} | null>;
+export type ChannelOverride = {
+    channel: "email" | "sms";
+    templateId: string | null;
+    templateSlug: string | null;
+    provider: string | null;
+};
+export declare function resolveChannelOverride(db: PostgresJsDatabase, run: NotificationReminderRunRow, rule: NotificationReminderRuleRow): Promise<ChannelOverride>;
+//# sourceMappingURL=service-reminder-run-state.d.ts.map

package/dist/service-reminder-run-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-reminder-run-state.d.ts","sourceRoot":"","sources":["../src/service-reminder-run-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAEL,wBAAwB,EAEzB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EACV,2BAA2B,EAC3B,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,qBAAqB,CAAA;AAE5B,MAAM,MAAM,wBAAwB,GAAG,CAAC,KAAK,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;AAE1F,MAAM,MAAM,0BAA0B,GAAG,OAAO,wBAAwB,CAAC,YAAY,CAAA;AAErF,wBAAgB,yBAAyB,IAAI,mBAAmB,CAO/D;AAED,wBAAgB,yBAAyB,IAAI,mBAAmB,CAO/D;AAED,wBAAsB,mBAAmB,CAAC,EAAE,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM;;;;;;;;;;;;;;;;UAOvF;AAED,wBAAsB,kBAAkB,CAAC,EAAE,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM;;;;;;;;;;;;;;;;;;;UAOrF;AAED,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,kBAAkB,EACtB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,IAAI,EACT,YAAY,EAAE,MAAM;;;;;;;;;;;;;;;;;;;UAcrB;AAED,wBAAsB,qBAAqB,CACzC,EAAE,EAAE,kBAAkB,EACtB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,IAAI,EACT,YAAY,EAAE,MAAM;;;;;;;;;;;;;;;;;;;UAcrB;AAED,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,kBAAkB,EACtB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,IAAI,EACT,sBAAsB,EAAE,MAAM,GAAG,IAAI;;;;;;;;;;;;;;;;;;;UAetC;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,OAAO,GAAG,KAAK,CAAA;IACxB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB,CAAA;AAED,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,kBAAkB,EACtB,GAAG,EAAE,0BAA0B,EAC/B,IAAI,EAAE,2BAA2B,GAChC,OAAO,CAAC,eAAe,CAAC,CA0B1B"}

package/dist/service-reminder-run-state.js

@@ -0,0 +1,100 @@
+import { eq } from "drizzle-orm";
+import { notificationReminderRules, notificationReminderRuns, notificationReminderStageChannels, } from "./schema.js";
+export function buildReminderSweepSummary() {
+    return {
+        processed: 0,
+        sent: 0,
+        skipped: 0,
+        failed: 0,
+    };
+}
+export function buildReminderQueueSummary() {
+    return {
+        processed: 0,
+        queued: 0,
+        skipped: 0,
+        failed: 0,
+    };
+}
+export async function getReminderRuleById(db, reminderRuleId) {
+    const [rule] = await db
+        .select()
+        .from(notificationReminderRules)
+        .where(eq(notificationReminderRules.id, reminderRuleId))
+        .limit(1);
+    return rule ?? null;
+}
+export async function getReminderRunById(db, reminderRunId) {
+    const [run] = await db
+        .select()
+        .from(notificationReminderRuns)
+        .where(eq(notificationReminderRuns.id, reminderRunId))
+        .limit(1);
+    return run ?? null;
+}
+export async function markReminderRunSkipped(db, reminderRunId, now, errorMessage) {
+    const [run] = await db
+        .update(notificationReminderRuns)
+        .set({
+        status: "skipped",
+        errorMessage,
+        processedAt: now,
+        updatedAt: now,
+    })
+        .where(eq(notificationReminderRuns.id, reminderRunId))
+        .returning();
+    return run ?? null;
+}
+export async function markReminderRunFailed(db, reminderRunId, now, errorMessage) {
+    const [run] = await db
+        .update(notificationReminderRuns)
+        .set({
+        status: "failed",
+        errorMessage,
+        processedAt: now,
+        updatedAt: now,
+    })
+        .where(eq(notificationReminderRuns.id, reminderRunId))
+        .returning();
+    return run ?? null;
+}
+export async function markReminderRunSent(db, reminderRunId, now, notificationDeliveryId) {
+    const [run] = await db
+        .update(notificationReminderRuns)
+        .set({
+        notificationDeliveryId,
+        status: "sent",
+        processedAt: now,
+        updatedAt: now,
+        errorMessage: null,
+    })
+        .where(eq(notificationReminderRuns.id, reminderRunId))
+        .returning();
+    return run ?? null;
+}
+export async function resolveChannelOverride(db, run, rule) {
+    const stageChannelId = run.metadata && typeof run.metadata === "object"
+        ? run.metadata.stageChannelId
+        : undefined;
+    if (stageChannelId) {
+        const [stageChannel] = await db
+            .select()
+            .from(notificationReminderStageChannels)
+            .where(eq(notificationReminderStageChannels.id, stageChannelId))
+            .limit(1);
+        if (stageChannel) {
+            return {
+                channel: stageChannel.channel,
+                templateId: stageChannel.templateId ?? null,
+                templateSlug: stageChannel.templateSlug ?? null,
+                provider: stageChannel.provider ?? null,
+            };
+        }
+    }
+    return {
+        channel: rule.channel,
+        templateId: rule.templateId ?? null,
+        templateSlug: rule.templateSlug ?? null,
+        provider: rule.provider ?? null,
+    };
+}

package/dist/service-reminder-stage-runs.d.ts

@@ -0,0 +1,6 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type ReminderDeliveryEnqueuer } from "./service-reminder-run-state.js";
+import type { NotificationService, ReminderQueueResult, ReminderSweepResult, RunDueRemindersInput } from "./service-shared.js";
+export declare function runStageBasedDueReminders(db: PostgresJsDatabase, dispatcher: NotificationService, input?: RunDueRemindersInput): Promise<ReminderSweepResult>;
+export declare function queueStageBasedDueReminders(db: PostgresJsDatabase, enqueueDelivery: ReminderDeliveryEnqueuer, input?: RunDueRemindersInput): Promise<ReminderQueueResult>;
+//# sourceMappingURL=service-reminder-stage-runs.d.ts.map

package/dist/service-reminder-stage-runs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-reminder-stage-runs.d.ts","sourceRoot":"","sources":["../src/service-reminder-stage-runs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAcjE,OAAO,EAML,KAAK,wBAAwB,EAC9B,MAAM,iCAAiC,CAAA;AAcxC,OAAO,KAAK,EAEV,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,qBAAqB,CAAA;AAsV5B,wBAAsB,yBAAyB,CAC7C,EAAE,EAAE,kBAAkB,EACtB,UAAU,EAAE,mBAAmB,EAC/B,KAAK,GAAE,oBAAyB,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CA6B9B;AAED,wBAAsB,2BAA2B,CAC/C,EAAE,EAAE,kBAAkB,EACtB,eAAe,EAAE,wBAAwB,EACzC,KAAK,GAAE,oBAAyB,GAC/B,OAAO,CAAC,mBAAmB,CAAC,CA6B9B"}