@voyant-travel/notifications 0.111.7

package/dist/service-reminder-stage-runs.js

@@ -0,0 +1,310 @@
+import { bookings, bookingTravelers } from "@voyant-travel/bookings/schema";
+import { bookingPaymentSchedules, invoices } from "@voyant-travel/finance";
+import { desc, eq } from "drizzle-orm";
+import { notificationReminderRuns, } from "./schema.js";
+import { sendInvoiceNotification, sendNotification } from "./service-deliveries.js";
+import { getPaymentReminderBookingStatusSkipReason, OPEN_PAYMENT_SCHEDULE_STATUSES, paymentScheduleStatusSkipReason, } from "./service-reminder-booking-context.js";
+import { buildReminderQueueSummary, buildReminderSweepSummary, markReminderRunFailed, markReminderRunSent, markReminderRunSkipped, } from "./service-reminder-run-state.js";
+import { applyQuietHours, evaluateStage, exceedsRecipientRateLimit, fetchTargetsForRule, getNotificationSettings, listActiveRulesByPriority, listChannelsForStage, listStagesForRule, loadHistory, suppressedByGroup, } from "./service-sequence.js";
+import { resolveReminderRecipient, startOfUtcDay, toDateString, toTimestamp, } from "./service-shared.js";
+function buildStageDedupeKey(ruleId, targetId, runDate, stageId, channel) {
+    return `${ruleId}:${targetId}:${runDate}:${stageId}:${channel}`;
+}
+async function fetchScheduleRow(db, scheduleId) {
+    const [row] = await db
+        .select()
+        .from(bookingPaymentSchedules)
+        .where(eq(bookingPaymentSchedules.id, scheduleId))
+        .limit(1);
+    return row ?? null;
+}
+async function fetchInvoiceRow(db, invoiceId) {
+    const [row] = await db.select().from(invoices).where(eq(invoices.id, invoiceId)).limit(1);
+    return row ?? null;
+}
+async function emitStageChannelRun(db, dispatcher, rule, stage, channelRow, target, recipient, scheduledAt, sendCountAtFire, enqueueDelivery, now) {
+    const runDate = toDateString(startOfUtcDay(scheduledAt));
+    const dedupeKey = buildStageDedupeKey(rule.id, target.id, runDate, stage.id, channelRow.channel);
+    const [existingRun] = await db
+        .select()
+        .from(notificationReminderRuns)
+        .where(eq(notificationReminderRuns.dedupeKey, dedupeKey))
+        .limit(1);
+    if (existingRun) {
+        return { status: "skipped", runId: existingRun.id };
+    }
+    const baseValues = {
+        reminderRuleId: rule.id,
+        targetType: rule.targetType,
+        targetId: target.id,
+        dedupeKey,
+        bookingId: target.bookingId,
+        personId: null,
+        organizationId: null,
+        paymentSessionId: null,
+        notificationDeliveryId: null,
+        recipient: recipient?.email ?? null,
+        scheduledFor: scheduledAt,
+        processedAt: now,
+        errorMessage: null,
+        metadata: {
+            stageId: stage.id,
+            stageOrderIndex: stage.orderIndex,
+            stageChannelId: channelRow.id,
+            channel: channelRow.channel,
+            anchor: stage.anchor,
+            sendCountAtFire,
+            ruleSlug: rule.slug,
+        },
+    };
+    if (!recipient?.email) {
+        const [run] = await db
+            .insert(notificationReminderRuns)
+            .values({ ...baseValues, status: "skipped", errorMessage: "no_recipient" })
+            .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
+            .returning();
+        return { status: "skipped", runId: run?.id ?? null };
+    }
+    if (enqueueDelivery && !dispatcher) {
+        const [queuedRun] = await db
+            .insert(notificationReminderRuns)
+            .values({ ...baseValues, status: "queued" })
+            .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
+            .returning();
+        if (!queuedRun)
+            return { status: "skipped", runId: null };
+        try {
+            await enqueueDelivery({ reminderRunId: queuedRun.id });
+            return { status: "queued", runId: queuedRun.id };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "enqueue_failed";
+            const failed = await markReminderRunFailed(db, queuedRun.id, new Date(), message);
+            return { status: "failed", runId: failed?.id ?? null };
+        }
+    }
+    if (!dispatcher) {
+        return { status: "skipped", runId: null };
+    }
+    const [processingRun] = await db
+        .insert(notificationReminderRuns)
+        .values({ ...baseValues, status: "processing" })
+        .onConflictDoNothing({ target: notificationReminderRuns.dedupeKey })
+        .returning();
+    if (!processingRun) {
+        return { status: "skipped", runId: null };
+    }
+    try {
+        const data = {
+            reminderRuleId: rule.id,
+            reminderRunId: processingRun.id,
+            stageId: stage.id,
+            stageOrderIndex: stage.orderIndex,
+            sendCountAtFire,
+        };
+        let delivery = null;
+        if (rule.targetType === "invoice") {
+            const invoice = await fetchInvoiceRow(db, target.id);
+            if (!invoice) {
+                return {
+                    status: "skipped",
+                    runId: (await markReminderRunSkipped(db, processingRun.id, new Date(), "invoice_not_found"))
+                        ?.id ?? null,
+                };
+            }
+            delivery = await sendInvoiceNotification(db, dispatcher, invoice.id, {
+                templateId: channelRow.templateId ?? null,
+                templateSlug: channelRow.templateSlug ?? null,
+                channel: channelRow.channel,
+                provider: channelRow.provider ?? null,
+                to: recipient.email,
+                data,
+                metadata: { reminderRuleId: rule.id, reminderRunId: processingRun.id, stageId: stage.id },
+                scheduledFor: scheduledAt.toISOString(),
+            });
+        }
+        else if (rule.targetType === "booking_payment_schedule") {
+            const schedule = await fetchScheduleRow(db, target.id);
+            if (!schedule) {
+                return {
+                    status: "skipped",
+                    runId: (await markReminderRunSkipped(db, processingRun.id, new Date(), "schedule_not_found"))
+                        ?.id ?? null,
+                };
+            }
+            if (!OPEN_PAYMENT_SCHEDULE_STATUSES.has(schedule.status)) {
+                return {
+                    status: "skipped",
+                    runId: (await markReminderRunSkipped(db, processingRun.id, new Date(), paymentScheduleStatusSkipReason(schedule.status)))?.id ?? null,
+                };
+            }
+            const bookingSkipReason = await getPaymentReminderBookingStatusSkipReason(db, schedule.bookingId);
+            if (bookingSkipReason) {
+                return {
+                    status: "skipped",
+                    runId: (await markReminderRunSkipped(db, processingRun.id, new Date(), bookingSkipReason))
+                        ?.id ?? null,
+                };
+            }
+            delivery = await sendNotification(db, dispatcher, {
+                templateId: channelRow.templateId ?? null,
+                templateSlug: channelRow.templateSlug ?? null,
+                channel: channelRow.channel,
+                provider: channelRow.provider ?? null,
+                to: recipient.email,
+                data: {
+                    ...data,
+                    bookingId: schedule.bookingId,
+                    dueDate: schedule.dueDate,
+                    amountCents: schedule.amountCents,
+                    currency: schedule.currency,
+                },
+                targetType: "booking_payment_schedule",
+                targetId: schedule.id,
+                bookingId: schedule.bookingId,
+                metadata: { reminderRuleId: rule.id, reminderRunId: processingRun.id, stageId: stage.id },
+                scheduledFor: scheduledAt.toISOString(),
+            });
+        }
+        else {
+            return {
+                status: "skipped",
+                runId: (await markReminderRunSkipped(db, processingRun.id, new Date(), "unsupported_target_type"))?.id ?? null,
+            };
+        }
+        const sent = await markReminderRunSent(db, processingRun.id, new Date(), delivery?.id ?? null);
+        return { status: "sent", runId: sent?.id ?? null };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "delivery_failed";
+        const failed = await markReminderRunFailed(db, processingRun.id, new Date(), message);
+        return { status: "failed", runId: failed?.id ?? null };
+    }
+}
+async function processStageRuleTargets(db, options) {
+    const tally = { processed: 0, sent: 0, queued: 0, skipped: 0, failed: 0 };
+    for (const target of options.targets) {
+        const history = await loadHistory(db, options.rule.id, target.id);
+        const decision = evaluateStage(options.rule, options.stages, target, history, options.today);
+        if (!decision.fire)
+            continue;
+        const channels = await listChannelsForStage(db, decision.stage.id);
+        if (channels.length === 0)
+            continue;
+        const booking = target.bookingId
+            ? ((await db
+                .select({
+                id: bookings.id,
+                bookingNumber: bookings.bookingNumber,
+                personId: bookings.personId,
+                organizationId: bookings.organizationId,
+                contactFirstName: bookings.contactFirstName,
+                contactLastName: bookings.contactLastName,
+                contactEmail: bookings.contactEmail,
+                contactPhone: bookings.contactPhone,
+                contactPreferredLanguage: bookings.contactPreferredLanguage,
+            })
+                .from(bookings)
+                .where(eq(bookings.id, target.bookingId))
+                .limit(1))[0] ?? null)
+            : null;
+        const participants = booking
+            ? await 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)
+            : [];
+        const recipient = booking ? resolveReminderRecipient(booking, participants) : null;
+        if (await suppressedByGroup(db, recipient?.email ?? null, options.rule.suppressionGroup, options.settings, options.now)) {
+            tally.skipped += 1;
+            continue;
+        }
+        const { scheduledAt } = applyQuietHours(options.now, decision.stage, options.settings);
+        for (const channelRow of channels) {
+            if (recipient?.email &&
+                (await exceedsRecipientRateLimit(db, recipient.email, channelRow.channel, options.settings, options.now))) {
+                tally.skipped += 1;
+                continue;
+            }
+            const result = await emitStageChannelRun(db, options.dispatcher, options.rule, decision.stage, channelRow, target, recipient ?? null, scheduledAt, decision.sendCountAtFire, options.enqueueDelivery, options.now);
+            tally.processed += 1;
+            if (result.status === "sent")
+                tally.sent += 1;
+            if (result.status === "queued")
+                tally.queued += 1;
+            if (result.status === "skipped")
+                tally.skipped += 1;
+            if (result.status === "failed")
+                tally.failed += 1;
+        }
+    }
+    return tally;
+}
+export async function runStageBasedDueReminders(db, dispatcher, input = {}) {
+    const now = toTimestamp(input.now) ?? new Date();
+    const today = startOfUtcDay(now);
+    const settings = await getNotificationSettings(db);
+    const rules = await listActiveRulesByPriority(db);
+    const summary = buildReminderSweepSummary();
+    for (const rule of rules) {
+        const stages = await listStagesForRule(db, rule.id);
+        if (stages.length === 0)
+            continue;
+        const targets = await fetchTargetsForRule(db, rule, stages, today);
+        if (targets.length === 0)
+            continue;
+        const tally = await processStageRuleTargets(db, {
+            rule,
+            stages,
+            targets,
+            settings,
+            today,
+            now,
+            dispatcher,
+            enqueueDelivery: null,
+        });
+        summary.processed += tally.processed;
+        summary.sent += tally.sent;
+        summary.skipped += tally.skipped;
+        summary.failed += tally.failed;
+    }
+    return summary;
+}
+export async function queueStageBasedDueReminders(db, enqueueDelivery, input = {}) {
+    const now = toTimestamp(input.now) ?? new Date();
+    const today = startOfUtcDay(now);
+    const settings = await getNotificationSettings(db);
+    const rules = await listActiveRulesByPriority(db);
+    const summary = buildReminderQueueSummary();
+    for (const rule of rules) {
+        const stages = await listStagesForRule(db, rule.id);
+        if (stages.length === 0)
+            continue;
+        const targets = await fetchTargetsForRule(db, rule, stages, today);
+        if (targets.length === 0)
+            continue;
+        const tally = await processStageRuleTargets(db, {
+            rule,
+            stages,
+            targets,
+            settings,
+            today,
+            now,
+            dispatcher: null,
+            enqueueDelivery,
+        });
+        summary.processed += tally.processed;
+        summary.queued += tally.queued;
+        summary.skipped += tally.skipped;
+        summary.failed += tally.failed;
+    }
+    return summary;
+}

package/dist/service-reminders.d.ts

@@ -0,0 +1,30 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type ReminderDeliveryEnqueuer } from "./service-reminder-run-state.js";
+import type { NotificationService, RunDueRemindersInput } from "./service-shared.js";
+export { type BookingEventReminderRuntimeOptions, bookingIsPaidInFullForNotification, dispatchReminderEventRules, } from "./service-reminder-events.js";
+export { queueStageBasedDueReminders, runStageBasedDueReminders, } from "./service-reminder-stage-runs.js";
+export declare function queueDueReminders(db: PostgresJsDatabase, input: RunDueRemindersInput | undefined, enqueueDelivery: ReminderDeliveryEnqueuer): Promise<import("./service-shared.js").ReminderQueueResult>;
+export declare function deliverReminderRun(db: PostgresJsDatabase, dispatcher: NotificationService, input: {
+    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 runDueReminders(db: PostgresJsDatabase, dispatcher: NotificationService, input?: RunDueRemindersInput): Promise<import("./service-shared.js").ReminderSweepResult>;
+//# sourceMappingURL=service-reminders.d.ts.map

package/dist/service-reminders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-reminders.d.ts","sourceRoot":"","sources":["../src/service-reminders.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAYjE,OAAO,EAQL,KAAK,wBAAwB,EAE9B,MAAM,iCAAiC,CAAA;AAKxC,OAAO,KAAK,EAEV,mBAAmB,EACnB,oBAAoB,EACrB,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EACL,KAAK,kCAAkC,EACvC,kCAAkC,EAClC,0BAA0B,GAC3B,MAAM,8BAA8B,CAAA;AACrC,OAAO,EACL,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,kCAAkC,CAAA;AA4KzC,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,kBAAkB,EACtB,KAAK,EAAE,oBAAoB,YAAK,EAChC,eAAe,EAAE,wBAAwB,8DAG1C;AAED,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,kBAAkB,EACtB,UAAU,EAAE,mBAAmB,EAC/B,KAAK,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;UAwDjC;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,kBAAkB,EACtB,UAAU,EAAE,mBAAmB,EAC/B,KAAK,GAAE,oBAAyB,8DAGjC"}

package/dist/service-reminders.js

@@ -0,0 +1,189 @@
+import { bookings, bookingTravelers } from "@voyant-travel/bookings/schema";
+import { bookingPaymentSchedules } from "@voyant-travel/finance";
+import { and, desc, eq } from "drizzle-orm";
+import { notificationReminderRuns } from "./schema.js";
+import { sendInvoiceNotification, sendNotification } from "./service-deliveries.js";
+import { bookingStatusSkipReason, getBookingPaymentNotificationContext, OPEN_PAYMENT_SCHEDULE_STATUSES, PAYABLE_BOOKING_STATUSES, paymentScheduleStatusSkipReason, serializeBookingPaymentContext, } from "./service-reminder-booking-context.js";
+import { getReminderRuleById, getReminderRunById, markReminderRunFailed, markReminderRunSent, markReminderRunSkipped, resolveChannelOverride, } from "./service-reminder-run-state.js";
+import { queueStageBasedDueReminders, runStageBasedDueReminders, } from "./service-reminder-stage-runs.js";
+import { listBookingNotificationItems, resolveReminderRecipient } from "./service-shared.js";
+export { bookingIsPaidInFullForNotification, dispatchReminderEventRules, } from "./service-reminder-events.js";
+export { queueStageBasedDueReminders, runStageBasedDueReminders, } from "./service-reminder-stage-runs.js";
+async function sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rule, now, channelOverride) {
+    const [schedule] = await db
+        .select()
+        .from(bookingPaymentSchedules)
+        .where(eq(bookingPaymentSchedules.id, run.targetId))
+        .limit(1);
+    if (!schedule) {
+        return markReminderRunSkipped(db, run.id, now, "Booking payment schedule not found for reminder run");
+    }
+    if (!OPEN_PAYMENT_SCHEDULE_STATUSES.has(schedule.status)) {
+        return markReminderRunSkipped(db, run.id, now, paymentScheduleStatusSkipReason(schedule.status));
+    }
+    const [booking] = await db
+        .select({
+        id: bookings.id,
+        bookingNumber: bookings.bookingNumber,
+        status: bookings.status,
+        personId: bookings.personId,
+        organizationId: bookings.organizationId,
+        contactFirstName: bookings.contactFirstName,
+        contactLastName: bookings.contactLastName,
+        contactEmail: bookings.contactEmail,
+        contactPhone: bookings.contactPhone,
+        contactPreferredLanguage: bookings.contactPreferredLanguage,
+        sellCurrency: bookings.sellCurrency,
+        sellAmountCents: bookings.sellAmountCents,
+        startDate: bookings.startDate,
+        endDate: bookings.endDate,
+    })
+        .from(bookings)
+        .where(eq(bookings.id, schedule.bookingId))
+        .limit(1);
+    if (!booking) {
+        return markReminderRunSkipped(db, run.id, now, "Booking not found for payment schedule");
+    }
+    if (!PAYABLE_BOOKING_STATUSES.has(booking.status)) {
+        return markReminderRunSkipped(db, run.id, now, bookingStatusSkipReason(booking.status));
+    }
+    const [participants, items, paymentContext] = 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),
+    ]);
+    const fallbackRecipient = resolveReminderRecipient(booking, participants);
+    const traveler = participants.find((entry) => entry.email === run.recipient) ?? fallbackRecipient ?? null;
+    const recipientEmail = run.recipient ?? traveler?.email ?? null;
+    if (!recipientEmail) {
+        return markReminderRunSkipped(db, run.id, now, "No traveler email available for booking payment reminder");
+    }
+    try {
+        const delivery = await sendNotification(db, dispatcher, {
+            templateId: channelOverride.templateId,
+            templateSlug: channelOverride.templateSlug,
+            channel: channelOverride.channel,
+            provider: channelOverride.provider,
+            to: recipientEmail,
+            data: {
+                bookingId: booking.id,
+                bookingNumber: booking.bookingNumber,
+                dueDate: schedule.dueDate,
+                amountCents: schedule.amountCents,
+                currency: schedule.currency,
+                scheduleType: schedule.scheduleType,
+                traveler: traveler
+                    ? {
+                        firstName: traveler.firstName,
+                        lastName: traveler.lastName,
+                        email: recipientEmail,
+                        participantType: traveler.participantType,
+                        isPrimary: traveler.isPrimary,
+                    }
+                    : null,
+                travelers: participants,
+                booking: {
+                    id: booking.id,
+                    bookingNumber: booking.bookingNumber,
+                    startDate: booking.startDate,
+                    endDate: booking.endDate,
+                    sellCurrency: booking.sellCurrency,
+                    sellAmountCents: booking.sellAmountCents,
+                },
+                ...serializeBookingPaymentContext(paymentContext, schedule),
+                items,
+            },
+            targetType: "booking_payment_schedule",
+            targetId: schedule.id,
+            bookingId: booking.id,
+            personId: booking.personId ?? null,
+            organizationId: booking.organizationId ?? null,
+            metadata: {
+                reminderRuleId: rule.id,
+                reminderRunId: run.id,
+            },
+            scheduledFor: run.scheduledFor.toISOString(),
+        });
+        return markReminderRunSent(db, run.id, new Date(), delivery?.id ?? null);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Notification reminder failed";
+        return markReminderRunFailed(db, run.id, new Date(), message);
+    }
+}
+async function sendQueuedInvoiceReminder(db, dispatcher, run, rule, now, channelOverride) {
+    const delivery = await sendInvoiceNotification(db, dispatcher, run.targetId, {
+        templateId: channelOverride.templateId,
+        templateSlug: channelOverride.templateSlug,
+        channel: channelOverride.channel,
+        provider: channelOverride.provider,
+        to: run.recipient ?? undefined,
+        data: {
+            reminderRunId: run.id,
+        },
+        metadata: {
+            reminderRuleId: rule.id,
+            reminderRunId: run.id,
+        },
+        scheduledFor: run.scheduledFor.toISOString(),
+    });
+    if (!delivery) {
+        return markReminderRunSkipped(db, run.id, now, "Invoice not found for reminder run");
+    }
+    return markReminderRunSent(db, run.id, new Date(), delivery.id ?? null);
+}
+export async function queueDueReminders(db, input = {}, enqueueDelivery) {
+    return queueStageBasedDueReminders(db, enqueueDelivery, input);
+}
+export async function deliverReminderRun(db, dispatcher, input) {
+    const now = new Date();
+    const [claimedRun] = await db
+        .update(notificationReminderRuns)
+        .set({
+        status: "processing",
+        errorMessage: null,
+        processedAt: now,
+        updatedAt: now,
+    })
+        .where(and(eq(notificationReminderRuns.id, input.reminderRunId), eq(notificationReminderRuns.status, "queued")))
+        .returning();
+    const run = claimedRun ?? (await getReminderRunById(db, input.reminderRunId));
+    if (!run) {
+        return null;
+    }
+    if (!claimedRun) {
+        return run;
+    }
+    const rule = await getReminderRuleById(db, run.reminderRuleId);
+    if (!rule) {
+        return markReminderRunFailed(db, run.id, new Date(), "Reminder rule not found");
+    }
+    const channelOverride = await resolveChannelOverride(db, run, rule);
+    try {
+        if (run.targetType === "booking_payment_schedule") {
+            return await sendQueuedBookingPaymentScheduleReminder(db, dispatcher, run, rule, now, channelOverride);
+        }
+        if (run.targetType === "invoice") {
+            return await sendQueuedInvoiceReminder(db, dispatcher, run, rule, now, channelOverride);
+        }
+        return markReminderRunSkipped(db, run.id, now, "Unsupported reminder target type");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Reminder delivery failed";
+        return markReminderRunFailed(db, run.id, new Date(), message);
+    }
+}
+export async function runDueReminders(db, dispatcher, input = {}) {
+    return runStageBasedDueReminders(db, dispatcher, input);
+}

package/dist/service-sequence-targets.d.ts

@@ -0,0 +1,50 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { NotificationReminderRule, NotificationReminderRuleStage } from "./schema.js";
+import type { ReminderTargetSnapshot } from "./service-sequence.js";
+/**
+ * Computes the date range a target's `due_date` (or `issue_date`) needs to
+ * fall in for any of the rule's stages to be inside their eligibility window
+ * today.
+ *
+ * From `inWindow`: today must satisfy
+ *   anchor + windowStartDays ≤ today ≤ anchor + windowEndDays
+ * Solving for anchor:
+ *   today − windowEndDays ≤ anchor ≤ today − windowStartDays
+ *
+ * Across all stages with anchor=`due_date`, we union the [start, end] ranges
+ * and use the resulting envelope as a SQL `BETWEEN` filter. Returns null when
+ * no stage is anchored on the requested column (e.g. all stages anchor on
+ * `departure_date`) — caller should skip the pushdown in that case.
+ */
+export declare function computeAnchorDateEnvelope(stages: NotificationReminderRuleStage[], today: Date, anchor: NotificationReminderRuleStage["anchor"]): {
+    from: string;
+    to: string;
+} | null;
+export type DateEnvelopes = {
+    /** When set, only fetch payment schedules whose `due_date` falls in this range. */
+    paymentScheduleDueDate?: {
+        from: string;
+        to: string;
+    };
+    /** When set, only fetch invoices whose `due_date` falls in this range. */
+    invoiceDueDate?: {
+        from: string;
+        to: string;
+    };
+    /** When set, only fetch invoices whose `issue_date` falls in this range. */
+    invoiceIssueDate?: {
+        from: string;
+        to: string;
+    };
+};
+export declare function fetchOpenPaymentScheduleTargets(db: PostgresJsDatabase, envelopes?: DateEnvelopes): Promise<ReminderTargetSnapshot[]>;
+export declare function fetchOpenInvoiceTargets(db: PostgresJsDatabase, envelopes?: DateEnvelopes): Promise<ReminderTargetSnapshot[]>;
+/**
+ * Per-rule target fetch that pushes a date envelope into the WHERE when all
+ * relevant stages share an anchor we can SQL-filter on (`due_date` for both
+ * target types, `invoice_issued_at` for invoices). Other anchors fall through
+ * to the unfiltered fetch — they're expected to be rare and the in-app
+ * window check still rejects misses.
+ */
+export declare function fetchTargetsForRule(db: PostgresJsDatabase, rule: NotificationReminderRule, stages?: NotificationReminderRuleStage[], today?: Date): Promise<ReminderTargetSnapshot[]>;
+//# sourceMappingURL=service-sequence-targets.d.ts.map

package/dist/service-sequence-targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-sequence-targets.d.ts","sourceRoot":"","sources":["../src/service-sequence-targets.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,KAAK,EAAE,wBAAwB,EAAE,6BAA6B,EAAE,MAAM,aAAa,CAAA;AAC1F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AAGnE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,6BAA6B,EAAE,EACvC,KAAK,EAAE,IAAI,EACX,MAAM,EAAE,6BAA6B,CAAC,QAAQ,CAAC,GAC9C;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgBrC;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,mFAAmF;IACnF,sBAAsB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAA;IACrD,0EAA0E;IAC1E,cAAc,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7C,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAA;CAChD,CAAA;AASD,wBAAsB,+BAA+B,CACnD,EAAE,EAAE,kBAAkB,EACtB,SAAS,GAAE,aAAkB,GAC5B,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAiCnC;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,kBAAkB,EACtB,SAAS,GAAE,aAAkB,GAC5B,OAAO,CAAC,sBAAsB,EAAE,CAAC,CA+CnC;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,kBAAkB,EACtB,IAAI,EAAE,wBAAwB,EAC9B,MAAM,GAAE,6BAA6B,EAAO,EAC5C,KAAK,GAAE,IAAiB,GACvB,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAcnC"}