@voyant-travel/notifications 0.111.7

package/dist/service-reminder-authoring.js

@@ -0,0 +1,247 @@
+import { asc, eq, inArray, or, sql } from "drizzle-orm";
+import { notificationReminderRuleAuthoringRequests, notificationReminderRuleStages, notificationReminderRules, notificationReminderStageChannels, notificationTemplates, } from "./schema.js";
+function field(path) {
+    return path
+        .map((segment) => (typeof segment === "number" ? `[${segment}]` : segment))
+        .join(".")
+        .replaceAll(".[", "[");
+}
+function issue(issues, code, path, message, fix) {
+    issues.push({ code, field: field(path), message, fix });
+}
+async function resolveTemplateRefs(db, refs) {
+    const ids = [...new Set(refs.map((ref) => ref.templateId).filter((id) => !!id))];
+    const slugs = [
+        ...new Set(refs.map((ref) => ref.templateSlug).filter((slug) => !!slug)),
+    ];
+    if (ids.length === 0 && slugs.length === 0) {
+        return new Map();
+    }
+    const rows = await db
+        .select({
+        id: notificationTemplates.id,
+        slug: notificationTemplates.slug,
+        channel: notificationTemplates.channel,
+    })
+        .from(notificationTemplates)
+        .where(or(ids.length > 0 ? inArray(notificationTemplates.id, ids) : undefined, slugs.length > 0 ? inArray(notificationTemplates.slug, slugs) : undefined));
+    const resolved = new Map();
+    for (const row of rows) {
+        resolved.set(`id:${row.id}`, row);
+        resolved.set(`slug:${row.slug}`, row);
+    }
+    return resolved;
+}
+function normalizeTemplateRef(ref, path, resolved, issues) {
+    const idMatch = ref.templateId ? resolved.get(`id:${ref.templateId}`) : null;
+    const slugMatch = ref.templateSlug ? resolved.get(`slug:${ref.templateSlug}`) : null;
+    if (ref.templateId && !idMatch) {
+        issue(issues, "template_not_found", [...path, "templateId"], `Notification template "${ref.templateId}" was not found.`, "Use an existing templateId or omit it and provide a resolvable templateSlug.");
+    }
+    if (ref.templateSlug && !slugMatch) {
+        issue(issues, "template_not_found", [...path, "templateSlug"], `Notification template "${ref.templateSlug}" was not found.`, "Use an existing templateSlug or omit it and provide a resolvable templateId.");
+    }
+    if (idMatch && slugMatch && idMatch.id !== slugMatch.id) {
+        issue(issues, "template_ref_mismatch", path, "templateId and templateSlug resolve to different notification templates.", "Keep only one template reference or make both references point at the same template.");
+    }
+    const template = idMatch ?? slugMatch;
+    if (!template)
+        return null;
+    return {
+        templateId: template.id,
+        templateSlug: template.slug,
+        template,
+    };
+}
+async function validateAndNormalizeComposeInput(db, input) {
+    const issues = [];
+    const refs = [input.rule];
+    for (const stage of input.stages) {
+        refs.push(...stage.channels);
+    }
+    const resolved = await resolveTemplateRefs(db, refs);
+    const ruleTemplate = normalizeTemplateRef(input.rule, ["rule"], resolved, issues);
+    const stageOrderIndexes = new Set();
+    const normalizedChannels = [];
+    input.stages.forEach((stage, stageIndex) => {
+        const stagePath = ["stages", stageIndex];
+        if (stageOrderIndexes.has(stage.orderIndex)) {
+            issue(issues, "duplicate_stage_order", [...stagePath, "orderIndex"], `Stage orderIndex ${stage.orderIndex} is used more than once.`, "Give each stage a unique orderIndex.");
+        }
+        stageOrderIndexes.add(stage.orderIndex);
+        if (stage.windowEndDays < stage.windowStartDays) {
+            issue(issues, "invalid_stage_window", [...stagePath, "windowEndDays"], "windowEndDays must be greater than or equal to windowStartDays.", "Set windowEndDays to the same value as windowStartDays or a later day offset.");
+        }
+        if (stage.cadenceKind === "every_n_days" && !stage.cadenceEveryDays) {
+            issue(issues, "cadence_every_days_required", [...stagePath, "cadenceEveryDays"], "cadenceEveryDays is required when cadenceKind is every_n_days.", "Set cadenceEveryDays to a positive integer or change cadenceKind.");
+        }
+        if (stage.cadenceKind === "escalating" &&
+            (!stage.cadenceIntervals || stage.cadenceIntervals.length === 0)) {
+            issue(issues, "cadence_intervals_required", [...stagePath, "cadenceIntervals"], "cadenceIntervals is required when cadenceKind is escalating.", "Provide at least one escalation interval or change cadenceKind.");
+        }
+        const channelOrderIndexes = new Set();
+        normalizedChannels[stageIndex] = [];
+        stage.channels.forEach((channel, channelIndex) => {
+            const channelPath = [...stagePath, "channels", channelIndex];
+            if (channelOrderIndexes.has(channel.orderIndex)) {
+                issue(issues, "duplicate_channel_order", [...channelPath, "orderIndex"], `Channel orderIndex ${channel.orderIndex} is used more than once in this stage.`, "Give each channel in the stage a unique orderIndex.");
+            }
+            channelOrderIndexes.add(channel.orderIndex);
+            if (channel.channel !== input.rule.channel) {
+                issue(issues, "channel_mismatch", [...channelPath, "channel"], `Stage channel "${channel.channel}" does not match rule channel "${input.rule.channel}".`, "Use the same channel on the rule and all stage channels.");
+            }
+            const channelTemplate = normalizeTemplateRef(channel, channelPath, resolved, issues) ?? ruleTemplate;
+            if (!channelTemplate) {
+                issue(issues, "template_required", channelPath, "Each stage channel needs a resolvable template from the channel or rule default.", "Set templateId or templateSlug on this channel, or set a rule-level template.");
+                return;
+            }
+            if (channelTemplate.template.channel !== channel.channel) {
+                issue(issues, "template_channel_mismatch", channel.templateId || channel.templateSlug ? channelPath : ["rule"], `Template "${channelTemplate.template.slug}" is ${channelTemplate.template.channel}, but the channel is ${channel.channel}.`, "Use a template whose channel matches the stage channel.");
+            }
+            normalizedChannels[stageIndex][channelIndex] = channelTemplate;
+        });
+    });
+    if (ruleTemplate && ruleTemplate.template.channel !== input.rule.channel) {
+        issue(issues, "template_channel_mismatch", ["rule"], `Rule template "${ruleTemplate.template.slug}" is ${ruleTemplate.template.channel}, but the rule channel is ${input.rule.channel}.`, "Use a rule-level template whose channel matches the rule channel.");
+    }
+    if (issues.length > 0) {
+        return { ok: false, issues };
+    }
+    return { ok: true, input, ruleTemplate, channels: normalizedChannels };
+}
+async function loadComposeResult(db, ruleId) {
+    const stages = await db
+        .select({
+        id: notificationReminderRuleStages.id,
+        orderIndex: notificationReminderRuleStages.orderIndex,
+    })
+        .from(notificationReminderRuleStages)
+        .where(eq(notificationReminderRuleStages.reminderRuleId, ruleId))
+        .orderBy(asc(notificationReminderRuleStages.orderIndex));
+    const stageIds = stages.map((stage) => stage.id);
+    const channels = stageIds.length > 0
+        ? await db
+            .select({
+            id: notificationReminderStageChannels.id,
+            stageId: notificationReminderStageChannels.stageId,
+            orderIndex: notificationReminderStageChannels.orderIndex,
+        })
+            .from(notificationReminderStageChannels)
+            .where(inArray(notificationReminderStageChannels.stageId, stageIds))
+            .orderBy(asc(notificationReminderStageChannels.stageId), asc(notificationReminderStageChannels.orderIndex))
+        : [];
+    return {
+        ruleId,
+        stages: stages.map((stage) => ({
+            id: stage.id,
+            orderIndex: stage.orderIndex,
+            channels: channels
+                .filter((channel) => channel.stageId === stage.id)
+                .map((channel) => ({ id: channel.id, orderIndex: channel.orderIndex })),
+        })),
+    };
+}
+async function withIdempotency(tx, key, build) {
+    if (!key) {
+        return { result: await build(), reused: false };
+    }
+    // agent-quality: raw-sql reviewed -- owner: notifications; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
+    await tx.execute(sql `SELECT pg_advisory_xact_lock(hashtextextended(${key}, 0))`);
+    const [existing] = await tx
+        .select({ reminderRuleId: notificationReminderRuleAuthoringRequests.reminderRuleId })
+        .from(notificationReminderRuleAuthoringRequests)
+        .where(eq(notificationReminderRuleAuthoringRequests.idempotencyKey, key))
+        .limit(1);
+    if (existing) {
+        return { result: await loadComposeResult(tx, existing.reminderRuleId), reused: true };
+    }
+    const result = await build();
+    await tx.insert(notificationReminderRuleAuthoringRequests).values({
+        idempotencyKey: key,
+        reminderRuleId: result.ruleId,
+        operation: "compose",
+    });
+    return { result, reused: false };
+}
+async function buildReminderRuleGraph(tx, normalized) {
+    const [rule] = await tx
+        .insert(notificationReminderRules)
+        .values({
+        slug: normalized.input.rule.slug,
+        name: normalized.input.rule.name,
+        status: normalized.input.rule.status,
+        targetType: normalized.input.rule.targetType,
+        channel: normalized.input.rule.channel,
+        provider: normalized.input.rule.provider ?? null,
+        templateId: normalized.ruleTemplate?.templateId ?? null,
+        templateSlug: normalized.ruleTemplate?.templateSlug ?? null,
+        priority: normalized.input.rule.priority,
+        suppressionGroup: normalized.input.rule.suppressionGroup ?? null,
+        isSystem: normalized.input.rule.isSystem,
+        metadata: normalized.input.rule.metadata ?? null,
+    })
+        .returning({ id: notificationReminderRules.id });
+    if (!rule)
+        throw new Error("Failed to create notification reminder rule");
+    const result = { ruleId: rule.id, stages: [] };
+    for (let stageIndex = 0; stageIndex < normalized.input.stages.length; stageIndex += 1) {
+        const stage = normalized.input.stages[stageIndex];
+        const [stageRow] = await tx
+            .insert(notificationReminderRuleStages)
+            .values({
+            reminderRuleId: rule.id,
+            orderIndex: stage.orderIndex,
+            name: stage.name ?? null,
+            anchor: stage.anchor,
+            windowStartDays: stage.windowStartDays,
+            windowEndDays: stage.windowEndDays,
+            cadenceKind: stage.cadenceKind,
+            cadenceEveryDays: stage.cadenceEveryDays ?? null,
+            cadenceIntervals: stage.cadenceIntervals ?? null,
+            maxSendsInStage: stage.maxSendsInStage ?? null,
+            respectQuietHours: stage.respectQuietHours,
+            metadata: stage.metadata ?? null,
+        })
+            .returning({ id: notificationReminderRuleStages.id });
+        if (!stageRow)
+            throw new Error("Failed to create notification reminder stage");
+        const stageResult = {
+            id: stageRow.id,
+            orderIndex: stage.orderIndex,
+            channels: [],
+        };
+        for (let channelIndex = 0; channelIndex < stage.channels.length; channelIndex += 1) {
+            const channel = stage.channels[channelIndex];
+            const template = normalized.channels[stageIndex][channelIndex];
+            const [channelRow] = await tx
+                .insert(notificationReminderStageChannels)
+                .values({
+                stageId: stageRow.id,
+                orderIndex: channel.orderIndex,
+                channel: channel.channel,
+                provider: channel.provider ?? null,
+                templateId: template.templateId,
+                templateSlug: template.templateSlug,
+                recipientKind: channel.recipientKind,
+                recipientRole: channel.recipientRole ?? null,
+                metadata: channel.metadata ?? null,
+            })
+                .returning({
+                id: notificationReminderStageChannels.id,
+                orderIndex: notificationReminderStageChannels.orderIndex,
+            });
+            if (!channelRow)
+                throw new Error("Failed to create notification reminder stage channel");
+            stageResult.channels.push({ id: channelRow.id, orderIndex: channelRow.orderIndex });
+        }
+        result.stages.push(stageResult);
+    }
+    return result;
+}
+export async function composeNotificationReminderRule(db, input, options = {}) {
+    const normalized = await validateAndNormalizeComposeInput(db, input);
+    if (!normalized.ok)
+        return { status: "invalid", issues: normalized.issues };
+    const { result, reused } = await db.transaction((tx) => withIdempotency(tx, options.idempotencyKey ?? input.idempotencyKey, () => buildReminderRuleGraph(tx, normalized)));
+    return { status: "ok", result, reused };
+}

package/dist/service-reminder-booking-context.d.ts

@@ -0,0 +1,94 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type BookingDocumentAttachmentResolver } from "./service-booking-documents.js";
+import type { BookingDocumentBundleItem, BookingPaymentScheduleRow } from "./service-shared.js";
+import type { NotificationAttachment } from "./types.js";
+export declare const PAYABLE_BOOKING_STATUSES: Set<string>;
+export declare const OPEN_PAYMENT_SCHEDULE_STATUSES: Set<string>;
+export interface BookingEventReminderRuntimeOptions {
+    documentAttachmentResolver?: BookingDocumentAttachmentResolver;
+}
+export declare function paymentScheduleStatusSkipReason(status: string): string;
+export declare function bookingStatusSkipReason(status: string): string;
+export declare function getPaymentReminderBookingStatusSkipReason(db: PostgresJsDatabase, bookingId: string): Promise<string | null>;
+export declare function getBookingPaymentNotificationContext(db: PostgresJsDatabase, bookingId: string): Promise<{
+    paymentSchedule: {
+        id: string;
+        bookingId: string;
+        scheduleType: "other" | "deposit" | "installment" | "balance" | "hold";
+        status: "paid" | "pending" | "cancelled" | "due" | "waived" | "expired";
+        dueDate: string;
+        currency: string;
+        amountCents: number;
+        createdAt: Date;
+    } | null;
+    invoice: {
+        id: string;
+        invoiceNumber: string;
+        invoiceType: "invoice" | "proforma" | "credit_note";
+        status: "void" | "draft" | "paid" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+        currency: string;
+        subtotalCents: number;
+        taxCents: number;
+        totalCents: number;
+        paidCents: number;
+        balanceDueCents: number;
+        issueDate: string;
+        dueDate: string;
+    } | null;
+    paymentSession: {
+        id: string;
+        status: "paid" | "pending" | "failed" | "cancelled" | "processing" | "expired" | "authorized" | "requires_redirect";
+        provider: string | null;
+        currency: string;
+        amountCents: number;
+        redirectUrl: string | null;
+        returnUrl: string | null;
+        cancelUrl: string | null;
+        expiresAt: Date | null;
+        paymentMethod: "other" | "credit_card" | "bank_transfer" | "voucher" | "debit_card" | "wallet" | "direct_bill" | "cash" | "cheque" | null;
+        externalReference: string | null;
+    } | null;
+}>;
+export declare function getBookingEventDocumentContext(db: PostgresJsDatabase, bookingId: string, attachmentResolver?: BookingDocumentAttachmentResolver): Promise<{
+    documents: BookingDocumentBundleItem[];
+    attachments: NotificationAttachment[];
+}>;
+export declare function serializeBookingPaymentContext(context: Awaited<ReturnType<typeof getBookingPaymentNotificationContext>>, paymentScheduleOverride?: BookingPaymentScheduleRow | null): {
+    invoice: {
+        id: string;
+        invoiceNumber: string;
+        invoiceType: "invoice" | "proforma" | "credit_note";
+        status: "void" | "draft" | "paid" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+        currency: string;
+        subtotalCents: number;
+        taxCents: number;
+        totalCents: number;
+        paidCents: number;
+        balanceDueCents: number;
+        issueDate: string;
+        dueDate: string;
+    } | null;
+    paymentSession: {
+        id: string;
+        status: "paid" | "pending" | "failed" | "cancelled" | "processing" | "expired" | "authorized" | "requires_redirect";
+        provider: string | null;
+        currency: string;
+        amountCents: number;
+        redirectUrl: string | null;
+        returnUrl: string | null;
+        cancelUrl: string | null;
+        expiresAt: Date | null;
+        paymentMethod: "other" | "credit_card" | "bank_transfer" | "voucher" | "debit_card" | "wallet" | "direct_bill" | "cash" | "cheque" | null;
+        externalReference: string | null;
+    } | null;
+    paymentSchedule: {
+        id: string;
+        dueDate: string;
+        amountCents: number;
+        currency: string;
+        scheduleType: "other" | "deposit" | "installment" | "balance" | "hold";
+        status: "paid" | "pending" | "cancelled" | "due" | "waived" | "expired";
+    } | null;
+};
+export declare function hasOutstandingBookingBalance(db: PostgresJsDatabase, bookingId: string): Promise<boolean>;
+//# sourceMappingURL=service-reminder-booking-context.d.ts.map

package/dist/service-reminder-booking-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-reminder-booking-context.d.ts","sourceRoot":"","sources":["../src/service-reminder-booking-context.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EACL,KAAK,iCAAiC,EAGvC,MAAM,gCAAgC,CAAA;AACvC,OAAO,KAAK,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAC/F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AAExD,eAAO,MAAM,wBAAwB,aAKnC,CAAA;AACF,eAAO,MAAM,8BAA8B,aAA8B,CAAA;AAEzE,MAAM,WAAW,kCAAkC;IACjD,0BAA0B,CAAC,EAAE,iCAAiC,CAAA;CAC/D;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,UAE7D;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,UAErD;AAED,wBAAsB,yCAAyC,CAC7D,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,0BAelB;AAED,wBAAsB,oCAAoC,CACxD,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsElB;AAED,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,kBAAkB,CAAC,EAAE,iCAAiC,GACrD,OAAO,CAAC;IACT,SAAS,EAAE,yBAAyB,EAAE,CAAA;IACtC,WAAW,EAAE,sBAAsB,EAAE,CAAA;CACtC,CAAC,CAgBD;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,oCAAoC,CAAC,CAAC,EACzE,uBAAuB,CAAC,EAAE,yBAAyB,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+C3D;AAED,wBAAsB,4BAA4B,CAAC,EAAE,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,oBAoC3F"}

package/dist/service-reminder-booking-context.js

@@ -0,0 +1,164 @@
+import { bookings } from "@voyant-travel/bookings/schema";
+import { bookingPaymentSchedules, invoices, paymentSessions } from "@voyant-travel/finance";
+import { and, asc, desc, eq, gt, or } from "drizzle-orm";
+import { bookingDocumentNotificationsService, createDefaultBookingDocumentAttachment, } from "./service-booking-documents.js";
+export const PAYABLE_BOOKING_STATUSES = new Set([
+    "on_hold",
+    "awaiting_payment",
+    "confirmed",
+    "in_progress",
+]);
+export const OPEN_PAYMENT_SCHEDULE_STATUSES = new Set(["pending", "due"]);
+export function paymentScheduleStatusSkipReason(status) {
+    return `payment_schedule_status_${status}`;
+}
+export function bookingStatusSkipReason(status) {
+    return `booking_status_${status}`;
+}
+export async function getPaymentReminderBookingStatusSkipReason(db, bookingId) {
+    const [booking] = await db
+        .select({ status: bookings.status })
+        .from(bookings)
+        .where(eq(bookings.id, bookingId))
+        .limit(1);
+    if (!booking) {
+        return "booking_not_found";
+    }
+    return PAYABLE_BOOKING_STATUSES.has(booking.status)
+        ? null
+        : bookingStatusSkipReason(booking.status);
+}
+export async function getBookingPaymentNotificationContext(db, bookingId) {
+    const [[paymentSchedule], [invoice], [paymentSession]] = await Promise.all([
+        db
+            .select({
+            id: bookingPaymentSchedules.id,
+            bookingId: bookingPaymentSchedules.bookingId,
+            scheduleType: bookingPaymentSchedules.scheduleType,
+            status: bookingPaymentSchedules.status,
+            dueDate: bookingPaymentSchedules.dueDate,
+            currency: bookingPaymentSchedules.currency,
+            amountCents: bookingPaymentSchedules.amountCents,
+            createdAt: bookingPaymentSchedules.createdAt,
+        })
+            .from(bookingPaymentSchedules)
+            .where(and(eq(bookingPaymentSchedules.bookingId, bookingId), or(eq(bookingPaymentSchedules.status, "pending"), eq(bookingPaymentSchedules.status, "due"))))
+            .orderBy(asc(bookingPaymentSchedules.dueDate), asc(bookingPaymentSchedules.createdAt))
+            .limit(1),
+        db
+            .select({
+            id: invoices.id,
+            invoiceNumber: invoices.invoiceNumber,
+            invoiceType: invoices.invoiceType,
+            status: invoices.status,
+            currency: invoices.currency,
+            subtotalCents: invoices.subtotalCents,
+            taxCents: invoices.taxCents,
+            totalCents: invoices.totalCents,
+            paidCents: invoices.paidCents,
+            balanceDueCents: invoices.balanceDueCents,
+            issueDate: invoices.issueDate,
+            dueDate: invoices.dueDate,
+        })
+            .from(invoices)
+            .where(eq(invoices.bookingId, bookingId))
+            .orderBy(desc(invoices.createdAt))
+            .limit(1),
+        db
+            .select({
+            id: paymentSessions.id,
+            status: paymentSessions.status,
+            provider: paymentSessions.provider,
+            currency: paymentSessions.currency,
+            amountCents: paymentSessions.amountCents,
+            redirectUrl: paymentSessions.redirectUrl,
+            returnUrl: paymentSessions.returnUrl,
+            cancelUrl: paymentSessions.cancelUrl,
+            expiresAt: paymentSessions.expiresAt,
+            paymentMethod: paymentSessions.paymentMethod,
+            externalReference: paymentSessions.externalReference,
+        })
+            .from(paymentSessions)
+            .where(eq(paymentSessions.bookingId, bookingId))
+            .orderBy(desc(paymentSessions.createdAt))
+            .limit(1),
+    ]);
+    return {
+        paymentSchedule: paymentSchedule ?? null,
+        invoice: invoice ?? null,
+        paymentSession: paymentSession ?? null,
+    };
+}
+export async function getBookingEventDocumentContext(db, bookingId, attachmentResolver) {
+    const bundle = await bookingDocumentNotificationsService.listBookingDocumentBundle(db, bookingId);
+    const documents = bundle?.documents ?? [];
+    if (documents.length === 0) {
+        return { documents, attachments: [] };
+    }
+    const resolver = attachmentResolver ??
+        (async (document) => createDefaultBookingDocumentAttachment(document));
+    const attachments = (await Promise.all(documents.map((document) => resolver(document)))).filter((attachment) => Boolean(attachment));
+    return { documents, attachments };
+}
+export function serializeBookingPaymentContext(context, paymentScheduleOverride) {
+    const schedule = paymentScheduleOverride ?? context.paymentSchedule;
+    return {
+        invoice: context.invoice
+            ? {
+                id: context.invoice.id,
+                invoiceNumber: context.invoice.invoiceNumber,
+                invoiceType: context.invoice.invoiceType,
+                status: context.invoice.status,
+                currency: context.invoice.currency,
+                subtotalCents: context.invoice.subtotalCents,
+                taxCents: context.invoice.taxCents,
+                totalCents: context.invoice.totalCents,
+                paidCents: context.invoice.paidCents,
+                balanceDueCents: context.invoice.balanceDueCents,
+                issueDate: context.invoice.issueDate,
+                dueDate: context.invoice.dueDate,
+            }
+            : null,
+        paymentSession: context.paymentSession
+            ? {
+                id: context.paymentSession.id,
+                status: context.paymentSession.status,
+                provider: context.paymentSession.provider,
+                currency: context.paymentSession.currency,
+                amountCents: context.paymentSession.amountCents,
+                redirectUrl: context.paymentSession.redirectUrl,
+                returnUrl: context.paymentSession.returnUrl,
+                cancelUrl: context.paymentSession.cancelUrl,
+                expiresAt: context.paymentSession.expiresAt,
+                paymentMethod: context.paymentSession.paymentMethod,
+                externalReference: context.paymentSession.externalReference,
+            }
+            : null,
+        paymentSchedule: schedule
+            ? {
+                id: schedule.id,
+                dueDate: schedule.dueDate,
+                amountCents: schedule.amountCents,
+                currency: schedule.currency,
+                scheduleType: schedule.scheduleType,
+                status: schedule.status,
+            }
+            : null,
+    };
+}
+export async function hasOutstandingBookingBalance(db, bookingId) {
+    const [openSchedule] = await db
+        .select({ id: bookingPaymentSchedules.id })
+        .from(bookingPaymentSchedules)
+        .where(and(eq(bookingPaymentSchedules.bookingId, bookingId), or(eq(bookingPaymentSchedules.status, "pending"), eq(bookingPaymentSchedules.status, "due"))))
+        .limit(1);
+    if (openSchedule) {
+        return true;
+    }
+    const [openInvoice] = await db
+        .select({ id: invoices.id })
+        .from(invoices)
+        .where(and(eq(invoices.bookingId, bookingId), gt(invoices.balanceDueCents, 0), or(eq(invoices.status, "issued"), eq(invoices.status, "partially_paid"), eq(invoices.status, "overdue"))))
+        .limit(1);
+    return Boolean(openInvoice);
+}

package/dist/service-reminder-events.d.ts

@@ -0,0 +1,33 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type BookingEventReminderRuntimeOptions } from "./service-reminder-booking-context.js";
+import type { NotificationReminderRuleRow, NotificationService } from "./service-shared.js";
+type ReminderTargetType = NotificationReminderRuleRow["targetType"];
+type BookingEventReminderTargetType = Extract<ReminderTargetType, "booking_confirmed" | "payment_complete" | "booking_cancelled_non_payment">;
+export declare function dispatchReminderEventRules(db: PostgresJsDatabase, dispatcher: NotificationService, input: {
+    targetType: BookingEventReminderTargetType;
+    bookingId: string;
+    paymentSessionId?: string | null;
+    eventData?: Record<string, unknown>;
+}, runtime?: BookingEventReminderRuntimeOptions): Promise<({
+    metadata: Record<string, unknown> | null;
+    scheduledFor: Date;
+    status: "sent" | "failed" | "queued" | "processing" | "skipped";
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    targetType: "invoice" | "booking_payment_schedule" | "booking_confirmed" | "payment_complete" | "booking_cancelled_non_payment";
+    targetId: string;
+    bookingId: string | null;
+    paymentSessionId: string | null;
+    personId: string | null;
+    organizationId: string | null;
+    errorMessage: string | null;
+    reminderRuleId: string;
+    notificationDeliveryId: string | null;
+    recipient: string | null;
+    dedupeKey: string;
+    processedAt: Date;
+} | null)[]>;
+export declare function bookingIsPaidInFullForNotification(db: PostgresJsDatabase, bookingId: string): Promise<boolean>;
+export type { BookingEventReminderRuntimeOptions } from "./service-reminder-booking-context.js";
+//# sourceMappingURL=service-reminder-events.d.ts.map

package/dist/service-reminder-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-reminder-events.d.ts","sourceRoot":"","sources":["../src/service-reminder-events.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAIjE,OAAO,EACL,KAAK,kCAAkC,EAKxC,MAAM,uCAAuC,CAAA;AAM9C,OAAO,KAAK,EAAE,2BAA2B,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAO3F,KAAK,kBAAkB,GAAG,2BAA2B,CAAC,YAAY,CAAC,CAAA;AACnE,KAAK,8BAA8B,GAAG,OAAO,CAC3C,kBAAkB,EAClB,mBAAmB,GAAG,kBAAkB,GAAG,+BAA+B,CAC3E,CAAA;AAwLD,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,kBAAkB,EACtB,UAAU,EAAE,mBAAmB,EAC/B,KAAK,EAAE;IACL,UAAU,EAAE,8BAA8B,CAAA;IAC1C,SAAS,EAAE,MAAM,CAAA;IACjB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACpC,EACD,OAAO,GAAE,kCAAuC;;;;;;;;;;;;;;;;;;;aAmBjD;AAED,wBAAsB,kCAAkC,CACtD,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,oBAGlB;AAED,YAAY,EAAE,kCAAkC,EAAE,MAAM,uCAAuC,CAAA"}