@voyant-travel/notifications 0.111.7

package/dist/service-templates.js

@@ -0,0 +1,293 @@
+import { and, desc, eq, ilike, or, sql } from "drizzle-orm";
+import { notificationDeliveries, notificationReminderRules, notificationReminderRuns, notificationTemplates, } from "./schema.js";
+import { buildWhereClause, paginate } from "./service-shared.js";
+function normalizeDateTime(value) {
+    if (!value)
+        return null;
+    return value instanceof Date ? value.toISOString() : value;
+}
+function normalizeReminderRun(row) {
+    return {
+        id: row.id,
+        reminderRuleId: row.reminderRuleId,
+        targetType: row.targetType,
+        targetId: row.targetId,
+        dedupeKey: row.dedupeKey,
+        status: row.status,
+        recipient: row.recipient ?? null,
+        scheduledFor: normalizeDateTime(row.scheduledFor),
+        processedAt: normalizeDateTime(row.processedAt),
+        errorMessage: row.errorMessage ?? null,
+        metadata: row.metadata ?? null,
+        createdAt: normalizeDateTime(row.createdAt),
+        updatedAt: normalizeDateTime(row.updatedAt),
+        links: {
+            bookingId: row.bookingId ?? null,
+            bookingPaymentScheduleId: row.targetType === "booking_payment_schedule" ? row.targetId : null,
+            invoiceId: row.targetType === "invoice" ? row.targetId : null,
+            paymentSessionId: row.paymentSessionId ?? null,
+            personId: row.personId ?? null,
+            organizationId: row.organizationId ?? null,
+            notificationDeliveryId: row.notificationDeliveryId ?? null,
+        },
+        reminderRule: {
+            id: row.reminderRuleId,
+            slug: row.ruleSlug,
+            name: row.ruleName,
+            status: row.ruleStatus,
+            targetType: row.ruleTargetType,
+            channel: row.ruleChannel,
+            provider: row.ruleProvider ?? null,
+            templateId: row.ruleTemplateId ?? null,
+            templateSlug: row.ruleTemplateSlug ?? null,
+        },
+        delivery: row.deliveryId &&
+            row.deliveryStatus &&
+            row.deliveryChannel &&
+            row.deliveryProvider &&
+            row.toAddress
+            ? {
+                id: row.deliveryId,
+                status: row.deliveryStatus,
+                channel: row.deliveryChannel,
+                provider: row.deliveryProvider,
+                toAddress: row.toAddress,
+                subject: row.deliverySubject ?? null,
+                sentAt: normalizeDateTime(row.sentAt),
+                failedAt: normalizeDateTime(row.failedAt),
+                errorMessage: row.deliveryErrorMessage ?? null,
+            }
+            : null,
+    };
+}
+export async function listTemplates(db, query) {
+    const conditions = [];
+    if (query.channel)
+        conditions.push(eq(notificationTemplates.channel, query.channel));
+    if (query.provider)
+        conditions.push(eq(notificationTemplates.provider, query.provider));
+    if (query.status)
+        conditions.push(eq(notificationTemplates.status, query.status));
+    if (query.search) {
+        const term = `%${query.search}%`;
+        conditions.push(or(ilike(notificationTemplates.slug, term), ilike(notificationTemplates.name, term)));
+    }
+    const where = buildWhereClause(conditions);
+    return paginate(db
+        .select()
+        .from(notificationTemplates)
+        .where(where)
+        .limit(query.limit)
+        .offset(query.offset)
+        .orderBy(desc(notificationTemplates.updatedAt)), db.select({ total: sql `count(*)::int` }).from(notificationTemplates).where(where), query.limit, query.offset);
+}
+export async function getTemplateById(db, id) {
+    const [row] = await db
+        .select()
+        .from(notificationTemplates)
+        .where(eq(notificationTemplates.id, id))
+        .limit(1);
+    return row ?? null;
+}
+export async function getTemplateBySlug(db, slug) {
+    const [row] = await db
+        .select()
+        .from(notificationTemplates)
+        .where(eq(notificationTemplates.slug, slug))
+        .limit(1);
+    return row ?? null;
+}
+export async function createTemplate(db, data) {
+    const [row] = await db.insert(notificationTemplates).values(data).returning();
+    return row ?? null;
+}
+export async function updateTemplate(db, id, data) {
+    const [row] = await db
+        .update(notificationTemplates)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(notificationTemplates.id, id))
+        .returning();
+    return row ?? null;
+}
+export async function deleteTemplate(db, id) {
+    const rows = await db
+        .delete(notificationTemplates)
+        .where(eq(notificationTemplates.id, id))
+        .returning({ id: notificationTemplates.id });
+    return rows.length > 0;
+}
+export async function listReminderRules(db, query) {
+    const conditions = [];
+    if (query.status)
+        conditions.push(eq(notificationReminderRules.status, query.status));
+    if (query.targetType)
+        conditions.push(eq(notificationReminderRules.targetType, query.targetType));
+    if (query.channel)
+        conditions.push(eq(notificationReminderRules.channel, query.channel));
+    if (query.search) {
+        const term = `%${query.search}%`;
+        conditions.push(or(ilike(notificationReminderRules.slug, term), ilike(notificationReminderRules.name, term)));
+    }
+    const where = buildWhereClause(conditions);
+    return paginate(db
+        .select()
+        .from(notificationReminderRules)
+        .where(where)
+        .limit(query.limit)
+        .offset(query.offset)
+        .orderBy(desc(notificationReminderRules.updatedAt)), db.select({ total: sql `count(*)::int` }).from(notificationReminderRules).where(where), query.limit, query.offset);
+}
+export async function getReminderRuleById(db, id) {
+    const [row] = await db
+        .select()
+        .from(notificationReminderRules)
+        .where(eq(notificationReminderRules.id, id))
+        .limit(1);
+    return row ?? null;
+}
+export async function createReminderRule(db, data) {
+    const [row] = await db.insert(notificationReminderRules).values(data).returning();
+    return row ?? null;
+}
+export async function updateReminderRule(db, id, data) {
+    const [row] = await db
+        .update(notificationReminderRules)
+        .set({ ...data, updatedAt: new Date() })
+        .where(eq(notificationReminderRules.id, id))
+        .returning();
+    return row ?? null;
+}
+export async function deleteReminderRule(db, id) {
+    const rows = await db
+        .delete(notificationReminderRules)
+        .where(eq(notificationReminderRules.id, id))
+        .returning({ id: notificationReminderRules.id });
+    return rows.length > 0;
+}
+export async function listReminderRuns(db, query) {
+    const conditions = [];
+    if (query.reminderRuleId) {
+        conditions.push(eq(notificationReminderRuns.reminderRuleId, query.reminderRuleId));
+    }
+    if (query.targetType)
+        conditions.push(eq(notificationReminderRuns.targetType, query.targetType));
+    if (query.targetId)
+        conditions.push(eq(notificationReminderRuns.targetId, query.targetId));
+    if (query.scheduleId) {
+        conditions.push(and(eq(notificationReminderRuns.targetType, "booking_payment_schedule"), eq(notificationReminderRuns.targetId, query.scheduleId)));
+    }
+    if (query.invoiceId) {
+        conditions.push(and(eq(notificationReminderRuns.targetType, "invoice"), eq(notificationReminderRuns.targetId, query.invoiceId)));
+    }
+    if (query.bookingId)
+        conditions.push(eq(notificationReminderRuns.bookingId, query.bookingId));
+    if (query.paymentSessionId) {
+        conditions.push(eq(notificationReminderRuns.paymentSessionId, query.paymentSessionId));
+    }
+    if (query.notificationDeliveryId) {
+        conditions.push(eq(notificationReminderRuns.notificationDeliveryId, query.notificationDeliveryId));
+    }
+    if (query.personId)
+        conditions.push(eq(notificationReminderRuns.personId, query.personId));
+    if (query.organizationId) {
+        conditions.push(eq(notificationReminderRuns.organizationId, query.organizationId));
+    }
+    if (query.recipient) {
+        conditions.push(eq(notificationReminderRuns.recipient, query.recipient));
+    }
+    if (query.status)
+        conditions.push(eq(notificationReminderRuns.status, query.status));
+    const where = buildWhereClause(conditions);
+    return paginate(db
+        .select({
+        id: notificationReminderRuns.id,
+        reminderRuleId: notificationReminderRuns.reminderRuleId,
+        targetType: notificationReminderRuns.targetType,
+        targetId: notificationReminderRuns.targetId,
+        dedupeKey: notificationReminderRuns.dedupeKey,
+        bookingId: notificationReminderRuns.bookingId,
+        personId: notificationReminderRuns.personId,
+        organizationId: notificationReminderRuns.organizationId,
+        paymentSessionId: notificationReminderRuns.paymentSessionId,
+        notificationDeliveryId: notificationReminderRuns.notificationDeliveryId,
+        status: notificationReminderRuns.status,
+        recipient: notificationReminderRuns.recipient,
+        scheduledFor: notificationReminderRuns.scheduledFor,
+        processedAt: notificationReminderRuns.processedAt,
+        errorMessage: notificationReminderRuns.errorMessage,
+        metadata: notificationReminderRuns.metadata,
+        createdAt: notificationReminderRuns.createdAt,
+        updatedAt: notificationReminderRuns.updatedAt,
+        ruleSlug: notificationReminderRules.slug,
+        ruleName: notificationReminderRules.name,
+        ruleStatus: notificationReminderRules.status,
+        ruleTargetType: notificationReminderRules.targetType,
+        ruleChannel: notificationReminderRules.channel,
+        ruleProvider: notificationReminderRules.provider,
+        ruleTemplateId: notificationReminderRules.templateId,
+        ruleTemplateSlug: notificationReminderRules.templateSlug,
+        deliveryId: notificationDeliveries.id,
+        deliveryStatus: notificationDeliveries.status,
+        deliveryChannel: notificationDeliveries.channel,
+        deliveryProvider: notificationDeliveries.provider,
+        toAddress: notificationDeliveries.toAddress,
+        deliverySubject: notificationDeliveries.subject,
+        sentAt: notificationDeliveries.sentAt,
+        failedAt: notificationDeliveries.failedAt,
+        deliveryErrorMessage: notificationDeliveries.errorMessage,
+    })
+        .from(notificationReminderRuns)
+        .innerJoin(notificationReminderRules, eq(notificationReminderRules.id, notificationReminderRuns.reminderRuleId))
+        .leftJoin(notificationDeliveries, eq(notificationDeliveries.id, notificationReminderRuns.notificationDeliveryId))
+        .where(where)
+        .limit(query.limit)
+        .offset(query.offset)
+        .orderBy(desc(notificationReminderRuns.createdAt))
+        .then((rows) => rows.map(normalizeReminderRun)), db.select({ total: sql `count(*)::int` }).from(notificationReminderRuns).where(where), query.limit, query.offset);
+}
+export async function getReminderRunById(db, id) {
+    const [row] = await db
+        .select({
+        id: notificationReminderRuns.id,
+        reminderRuleId: notificationReminderRuns.reminderRuleId,
+        targetType: notificationReminderRuns.targetType,
+        targetId: notificationReminderRuns.targetId,
+        dedupeKey: notificationReminderRuns.dedupeKey,
+        bookingId: notificationReminderRuns.bookingId,
+        personId: notificationReminderRuns.personId,
+        organizationId: notificationReminderRuns.organizationId,
+        paymentSessionId: notificationReminderRuns.paymentSessionId,
+        notificationDeliveryId: notificationReminderRuns.notificationDeliveryId,
+        status: notificationReminderRuns.status,
+        recipient: notificationReminderRuns.recipient,
+        scheduledFor: notificationReminderRuns.scheduledFor,
+        processedAt: notificationReminderRuns.processedAt,
+        errorMessage: notificationReminderRuns.errorMessage,
+        metadata: notificationReminderRuns.metadata,
+        createdAt: notificationReminderRuns.createdAt,
+        updatedAt: notificationReminderRuns.updatedAt,
+        ruleSlug: notificationReminderRules.slug,
+        ruleName: notificationReminderRules.name,
+        ruleStatus: notificationReminderRules.status,
+        ruleTargetType: notificationReminderRules.targetType,
+        ruleChannel: notificationReminderRules.channel,
+        ruleProvider: notificationReminderRules.provider,
+        ruleTemplateId: notificationReminderRules.templateId,
+        ruleTemplateSlug: notificationReminderRules.templateSlug,
+        deliveryId: notificationDeliveries.id,
+        deliveryStatus: notificationDeliveries.status,
+        deliveryChannel: notificationDeliveries.channel,
+        deliveryProvider: notificationDeliveries.provider,
+        toAddress: notificationDeliveries.toAddress,
+        deliverySubject: notificationDeliveries.subject,
+        sentAt: notificationDeliveries.sentAt,
+        failedAt: notificationDeliveries.failedAt,
+        deliveryErrorMessage: notificationDeliveries.errorMessage,
+    })
+        .from(notificationReminderRuns)
+        .innerJoin(notificationReminderRules, eq(notificationReminderRules.id, notificationReminderRuns.reminderRuleId))
+        .leftJoin(notificationDeliveries, eq(notificationDeliveries.id, notificationReminderRuns.notificationDeliveryId))
+        .where(eq(notificationReminderRuns.id, id))
+        .limit(1);
+    return row ? normalizeReminderRun(row) : null;
+}

package/dist/service.d.ts

@@ -0,0 +1,273 @@
+export { createDefaultBookingDocumentAttachment } from "./service-booking-documents.js";
+export type { NotificationService } from "./service-shared.js";
+export { createNotificationService, NotificationError, previewNotificationTemplate, renderNotificationTemplate, summarizeNotificationAttachments, } from "./service-shared.js";
+import { createDefaultBookingDocumentAttachment } from "./service-booking-documents.js";
+import { getDeliveryById, listDeliveries, resendDelivery, sendInvoiceNotification, sendNotification, sendPaymentSessionNotification } from "./service-deliveries.js";
+import { composeNotificationReminderRule } from "./service-reminder-authoring.js";
+import { runDueReminders } from "./service-reminders.js";
+import { previewReminders } from "./service-sequence.js";
+import { previewNotificationTemplate } from "./service-shared.js";
+import { createReminderRuleStage, createStageChannel, deleteReminderRuleStage, deleteStageChannel, getNotificationSettingsRecord, getReminderRuleStageById, listReminderRuleStages, listStageChannels, reorderReminderRuleStages, updateReminderRuleStage, updateStageChannel, upsertNotificationSettings } from "./service-stages.js";
+import { createReminderRule, createTemplate, deleteReminderRule, deleteTemplate, getReminderRuleById, getReminderRunById, getTemplateById, getTemplateBySlug, listReminderRules, listReminderRuns, listTemplates, updateReminderRule, updateTemplate } from "./service-templates.js";
+export declare const notificationsService: {
+    listTemplates: typeof listTemplates;
+    getTemplateById: typeof getTemplateById;
+    getTemplateBySlug: typeof getTemplateBySlug;
+    createTemplate: typeof createTemplate;
+    updateTemplate: typeof updateTemplate;
+    deleteTemplate: typeof deleteTemplate;
+    previewNotificationTemplate: typeof previewNotificationTemplate;
+    listDeliveries: typeof listDeliveries;
+    getDeliveryById: typeof getDeliveryById;
+    resendDelivery: typeof resendDelivery;
+    sendNotification: typeof sendNotification;
+    listReminderRules: typeof listReminderRules;
+    getReminderRuleById: typeof getReminderRuleById;
+    getReminderRunById: typeof getReminderRunById;
+    createReminderRule: typeof createReminderRule;
+    composeNotificationReminderRule: typeof composeNotificationReminderRule;
+    updateReminderRule: typeof updateReminderRule;
+    deleteReminderRule: typeof deleteReminderRule;
+    listReminderRuns: typeof listReminderRuns;
+    runDueReminders: typeof runDueReminders;
+    previewReminders: typeof previewReminders;
+    listReminderRuleStages: typeof listReminderRuleStages;
+    getReminderRuleStageById: typeof getReminderRuleStageById;
+    createReminderRuleStage: typeof createReminderRuleStage;
+    updateReminderRuleStage: typeof updateReminderRuleStage;
+    deleteReminderRuleStage: typeof deleteReminderRuleStage;
+    reorderReminderRuleStages: typeof reorderReminderRuleStages;
+    listStageChannels: typeof listStageChannels;
+    createStageChannel: typeof createStageChannel;
+    updateStageChannel: typeof updateStageChannel;
+    deleteStageChannel: typeof deleteStageChannel;
+    getNotificationSettings: typeof getNotificationSettingsRecord;
+    upsertNotificationSettings: typeof upsertNotificationSettings;
+    sendPaymentSessionNotification: typeof sendPaymentSessionNotification;
+    sendInvoiceNotification: typeof sendInvoiceNotification;
+    listBookingDocumentBundle: (db: import("drizzle-orm/postgres-js").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: import("drizzle-orm/postgres-js").PostgresJsDatabase, dispatcher: import("./service-shared.js").NotificationService, bookingId: string, input: import("./service-shared.js").SendBookingDocumentsNotificationInput, runtime?: import("./service-booking-documents.js").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;
+        };
+    }>;
+    confirmAndDispatchBooking: (db: import("drizzle-orm/postgres-js").PostgresJsDatabase, dispatcher: import("./service-shared.js").NotificationService, bookingId: string, input: {
+        sendNotification?: boolean;
+    } & import("./service-shared.js").SendBookingDocumentsNotificationInput, runtime?: import("./service-booking-documents.js").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;
+    }>;
+    createDefaultBookingDocumentAttachment: typeof createDefaultBookingDocumentAttachment;
+};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sCAAsC,EAAE,MAAM,gCAAgC,CAAA;AACvF,YAAY,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EACjB,2BAA2B,EAC3B,0BAA0B,EAC1B,gCAAgC,GACjC,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAEL,sCAAsC,EACvC,MAAM,gCAAgC,CAAA;AACvC,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,gBAAgB,EAChB,8BAA8B,EAC/B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,+BAA+B,EAAE,MAAM,iCAAiC,CAAA;AACjF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,2BAA2B,EAAE,MAAM,qBAAqB,CAAA;AACjE,OAAO,EACL,uBAAuB,EACvB,kBAAkB,EAClB,uBAAuB,EACvB,kBAAkB,EAClB,6BAA6B,EAC7B,wBAAwB,EACxB,sBAAsB,EACtB,iBAAiB,EACjB,yBAAyB,EACzB,uBAAuB,EACvB,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,aAAa,EACb,kBAAkB,EAClB,cAAc,EACf,MAAM,wBAAwB,CAAA;AAE/B,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA0CkpT,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CADnrT,CAAA"}

package/dist/service.js

@@ -0,0 +1,51 @@
+export { createDefaultBookingDocumentAttachment } from "./service-booking-documents.js";
+export { createNotificationService, NotificationError, previewNotificationTemplate, renderNotificationTemplate, summarizeNotificationAttachments, } from "./service-shared.js";
+import { bookingDocumentNotificationsService, createDefaultBookingDocumentAttachment, } from "./service-booking-documents.js";
+import { getDeliveryById, listDeliveries, resendDelivery, sendInvoiceNotification, sendNotification, sendPaymentSessionNotification, } from "./service-deliveries.js";
+import { composeNotificationReminderRule } from "./service-reminder-authoring.js";
+import { runDueReminders } from "./service-reminders.js";
+import { previewReminders } from "./service-sequence.js";
+import { previewNotificationTemplate } from "./service-shared.js";
+import { createReminderRuleStage, createStageChannel, deleteReminderRuleStage, deleteStageChannel, getNotificationSettingsRecord, getReminderRuleStageById, listReminderRuleStages, listStageChannels, reorderReminderRuleStages, updateReminderRuleStage, updateStageChannel, upsertNotificationSettings, } from "./service-stages.js";
+import { createReminderRule, createTemplate, deleteReminderRule, deleteTemplate, getReminderRuleById, getReminderRunById, getTemplateById, getTemplateBySlug, listReminderRules, listReminderRuns, listTemplates, updateReminderRule, updateTemplate, } from "./service-templates.js";
+export const notificationsService = {
+    listTemplates,
+    getTemplateById,
+    getTemplateBySlug,
+    createTemplate,
+    updateTemplate,
+    deleteTemplate,
+    previewNotificationTemplate,
+    listDeliveries,
+    getDeliveryById,
+    resendDelivery,
+    sendNotification,
+    listReminderRules,
+    getReminderRuleById,
+    getReminderRunById,
+    createReminderRule,
+    composeNotificationReminderRule,
+    updateReminderRule,
+    deleteReminderRule,
+    listReminderRuns,
+    runDueReminders,
+    previewReminders,
+    listReminderRuleStages,
+    getReminderRuleStageById,
+    createReminderRuleStage,
+    updateReminderRuleStage,
+    deleteReminderRuleStage,
+    reorderReminderRuleStages,
+    listStageChannels,
+    createStageChannel,
+    updateStageChannel,
+    deleteStageChannel,
+    getNotificationSettings: getNotificationSettingsRecord,
+    upsertNotificationSettings,
+    sendPaymentSessionNotification,
+    sendInvoiceNotification,
+    listBookingDocumentBundle: bookingDocumentNotificationsService.listBookingDocumentBundle,
+    sendBookingDocumentsNotification: bookingDocumentNotificationsService.sendBookingDocumentsNotification,
+    confirmAndDispatchBooking: bookingDocumentNotificationsService.confirmAndDispatchBooking,
+    createDefaultBookingDocumentAttachment,
+};

package/dist/task-runtime.d.ts

@@ -0,0 +1,19 @@
+import type { ExecutionLockManager } from "@voyant-travel/core";
+import type { NotificationProvider } from "./types.js";
+export type NotificationTaskEnv = Record<string, unknown>;
+export type ReminderDeliveryJob = {
+    reminderRunId: string;
+};
+export type NotificationTaskRuntime = {
+    providers: ReadonlyArray<NotificationProvider>;
+    reminderSweepLockManager?: ExecutionLockManager;
+    enqueueReminderDelivery?: (job: ReminderDeliveryJob) => Promise<void>;
+};
+export type NotificationTaskRuntimeOptions = {
+    providers?: ReadonlyArray<NotificationProvider>;
+    reminderSweepLockManager?: ExecutionLockManager;
+    enqueueReminderDelivery?: (job: ReminderDeliveryJob) => Promise<void>;
+    resolveProviders?: (env: NotificationTaskEnv) => ReadonlyArray<NotificationProvider>;
+};
+export declare function buildNotificationTaskRuntime(env: NotificationTaskEnv, options?: NotificationTaskRuntimeOptions): NotificationTaskRuntime;
+//# sourceMappingURL=task-runtime.d.ts.map

package/dist/task-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-runtime.d.ts","sourceRoot":"","sources":["../src/task-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAE/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;AAEzD,MAAM,MAAM,mBAAmB,GAAG;IAChC,aAAa,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,SAAS,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAA;IAC9C,wBAAwB,CAAC,EAAE,oBAAoB,CAAA;IAC/C,uBAAuB,CAAC,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACtE,CAAA;AAED,MAAM,MAAM,8BAA8B,GAAG;IAC3C,SAAS,CAAC,EAAE,aAAa,CAAC,oBAAoB,CAAC,CAAA;IAC/C,wBAAwB,CAAC,EAAE,oBAAoB,CAAA;IAC/C,uBAAuB,CAAC,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACrE,gBAAgB,CAAC,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,aAAa,CAAC,oBAAoB,CAAC,CAAA;CACrF,CAAA;AAED,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,mBAAmB,EACxB,OAAO,GAAE,8BAAmC,GAC3C,uBAAuB,CAazB"}

package/dist/task-runtime.js

@@ -0,0 +1,11 @@
+export function buildNotificationTaskRuntime(env, options = {}) {
+    const providers = options.resolveProviders?.(env) ?? options.providers;
+    if (!providers) {
+        throw new Error("buildNotificationTaskRuntime requires `providers` or `resolveProviders` — there are no default providers.");
+    }
+    return {
+        providers,
+        reminderSweepLockManager: options.reminderSweepLockManager,
+        enqueueReminderDelivery: options.enqueueReminderDelivery,
+    };
+}

package/dist/tasks/deliver-reminder.d.ts

@@ -0,0 +1,9 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type NotificationTaskEnv, type NotificationTaskRuntimeOptions } from "../task-runtime.js";
+export declare function deliverQueuedNotificationReminder(db: PostgresJsDatabase, env: NotificationTaskEnv, input: {
+    reminderRunId: string;
+}, options?: NotificationTaskRuntimeOptions): Promise<{
+    reminderRunId: string;
+    status: "sent" | "failed" | "queued" | "processing" | "skipped" | null;
+}>;
+//# sourceMappingURL=deliver-reminder.d.ts.map

package/dist/tasks/deliver-reminder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliver-reminder.d.ts","sourceRoot":"","sources":["../../src/tasks/deliver-reminder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAIjE,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,8BAA8B,EACpC,MAAM,oBAAoB,CAAA;AAE3B,wBAAsB,iCAAiC,CACrD,EAAE,EAAE,kBAAkB,EACtB,GAAG,EAAE,mBAAmB,EACxB,KAAK,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,EAChC,OAAO,GAAE,8BAAmC;;;GAU7C"}