@voyantjs/checkout 0.24.1 → 0.24.3

package/dist/service.js

@@ -0,0 +1,497 @@
+import { bookingItems, bookings, bookingTravelers } from "@voyantjs/bookings";
+import { bookingPaymentSchedules, financeService, invoiceLineItems, invoiceNumberSeries, invoices, } from "@voyantjs/finance";
+import { notificationDeliveries, notificationReminderRules, notificationReminderRuns, notificationsService, } from "@voyantjs/notifications";
+import { and, asc, desc, eq, gt, inArray, sql } from "drizzle-orm";
+const OUTSTANDING_SCHEDULE_STATUSES = ["pending", "due"];
+const OUTSTANDING_INVOICE_STATUSES = [
+    "draft",
+    "sent",
+    "partially_paid",
+    "overdue",
+];
+function normalizeRequiredDateTime(value) {
+    return value instanceof Date ? value.toISOString() : value;
+}
+function defaultPaymentPlan(options) {
+    return {
+        depositMode: options.defaultPaymentPlan?.depositMode ?? "percentage",
+        depositValue: options.defaultPaymentPlan?.depositValue ?? 30,
+        balanceDueDaysBeforeStart: options.defaultPaymentPlan?.balanceDueDaysBeforeStart ?? 30,
+        clearExistingPending: options.defaultPaymentPlan?.clearExistingPending ?? true,
+        createGuarantee: options.defaultPaymentPlan?.createGuarantee ?? false,
+        guaranteeType: options.defaultPaymentPlan?.guaranteeType ?? "deposit",
+        notes: options.defaultPaymentPlan?.notes ?? null,
+    };
+}
+export function resolvePaymentSessionTarget(method, stage, override, options) {
+    if (method === "bank_transfer")
+        return "invoice";
+    if (override)
+        return override;
+    if (stage === "reminder")
+        return options.defaultReminderCardCollectionTarget ?? "schedule";
+    return options.defaultCardCollectionTarget ?? "schedule";
+}
+function resolveDocumentType(method, target, options) {
+    if (method === "bank_transfer") {
+        return options.defaultBankTransferDocumentType ?? "proforma";
+    }
+    if (target === "invoice") {
+        return "invoice";
+    }
+    return null;
+}
+function fallbackInvoiceNumber(bookingNumber, documentType, amountCents) {
+    const stamp = Date.now().toString(36).toUpperCase();
+    const suffix = documentType === "proforma" ? "PF" : "INV";
+    return `${bookingNumber}-${suffix}-${amountCents}-${stamp}`;
+}
+function lineDescription(booking, schedule, stage) {
+    if (!schedule) {
+        return `Booking ${booking.bookingNumber}`;
+    }
+    const kind = schedule.scheduleType === "deposit" ? "deposit" : schedule.scheduleType;
+    if (stage === "reminder") {
+        return `Booking ${booking.bookingNumber} ${kind} reminder`;
+    }
+    return `Booking ${booking.bookingNumber} ${kind}`;
+}
+function normalizeExactAmountCents(amountCents) {
+    return typeof amountCents === "number" && Number.isFinite(amountCents) && amountCents > 0
+        ? Math.round(amountCents)
+        : null;
+}
+function resolveCheckoutIntent(input) {
+    if ("intent" in input && input.intent) {
+        return input.intent;
+    }
+    if (typeof input.amountCents === "number" &&
+        Number.isFinite(input.amountCents) &&
+        input.amountCents > 0) {
+        return "custom";
+    }
+    if (input.stage === "initial") {
+        return "deposit";
+    }
+    if (input.stage === "reminder") {
+        return "balance";
+    }
+    return "custom";
+}
+function resolveCheckoutSubject(input) {
+    if (input.bookingId && input.sessionId && input.bookingId !== input.sessionId) {
+        throw new Error("bookingId and sessionId must refer to the same booking session");
+    }
+    if (input.bookingId) {
+        return {
+            bookingId: input.bookingId,
+            sessionId: input.sessionId ?? input.bookingId,
+            sourceType: "booking",
+        };
+    }
+    if (input.sessionId) {
+        return {
+            bookingId: input.sessionId,
+            sessionId: input.sessionId,
+            sourceType: "session",
+        };
+    }
+    throw new Error("Provide a bookingId or sessionId");
+}
+function toInvoiceDueDateTime(value) {
+    return value ? `${value}T00:00:00.000Z` : null;
+}
+function buildBankTransferInstructions(invoice, details, callNotes) {
+    if (!details) {
+        return null;
+    }
+    return {
+        provider: details.provider ?? null,
+        invoiceId: invoice.id,
+        invoiceNumber: invoice.invoiceNumber,
+        documentType: invoice.invoiceType === "proforma" ? "proforma" : "invoice",
+        amountCents: invoice.balanceDueCents,
+        // Currency always tracks the invoice — the deploy-wide bank-transfer
+        // block can't predict what the customer is buying. EUR booking +
+        // RON-default env would have shown the wrong currency to the customer.
+        currency: invoice.currency,
+        dueDate: toInvoiceDueDateTime(invoice.dueDate),
+        beneficiary: details.beneficiary,
+        iban: details.iban,
+        bankName: details.bankName ?? null,
+        // Per-call notes win over deploy-wide boilerplate — the caller knows
+        // booking context (invoice number, due date, etc.) the env can't.
+        notes: callNotes ?? details.notes ?? null,
+    };
+}
+async function loadBookingContext(db, bookingId) {
+    const [booking] = await db.select().from(bookings).where(eq(bookings.id, bookingId)).limit(1);
+    if (!booking)
+        return null;
+    const [items, participants, schedules, outstandingInvoices] = await Promise.all([
+        db
+            .select()
+            .from(bookingItems)
+            .where(eq(bookingItems.bookingId, bookingId))
+            .orderBy(bookingItems.createdAt),
+        db
+            .select()
+            .from(bookingTravelers)
+            .where(eq(bookingTravelers.bookingId, bookingId))
+            .orderBy(desc(bookingTravelers.isPrimary), bookingTravelers.createdAt),
+        db
+            .select()
+            .from(bookingPaymentSchedules)
+            .where(and(eq(bookingPaymentSchedules.bookingId, bookingId), inArray(bookingPaymentSchedules.status, OUTSTANDING_SCHEDULE_STATUSES)))
+            .orderBy(asc(bookingPaymentSchedules.dueDate), asc(bookingPaymentSchedules.createdAt)),
+        db
+            .select()
+            .from(invoices)
+            .where(and(eq(invoices.bookingId, bookingId), inArray(invoices.status, OUTSTANDING_INVOICE_STATUSES), gt(invoices.balanceDueCents, 0)))
+            .orderBy(desc(invoices.createdAt)),
+    ]);
+    return {
+        booking,
+        items,
+        participants,
+        schedules,
+        outstandingInvoices,
+    };
+}
+async function ensurePaymentPlanIfNeeded(db, bookingId, existingSchedules, input, options) {
+    if (existingSchedules.length > 0 || !input.ensureDefaultPaymentPlan) {
+        return existingSchedules;
+    }
+    const created = await financeService.applyDefaultBookingPaymentPlan(db, bookingId, {
+        ...defaultPaymentPlan(options),
+        ...(input.paymentPlan ?? {}),
+    });
+    return created ?? [];
+}
+async function allocateDocumentNumber(db, bookingNumber, documentType, amountCents) {
+    const [series] = await db
+        .select()
+        .from(invoiceNumberSeries)
+        .where(eq(invoiceNumberSeries.scope, documentType))
+        .orderBy(desc(invoiceNumberSeries.active), asc(invoiceNumberSeries.createdAt))
+        .limit(1);
+    if (!series) {
+        return fallbackInvoiceNumber(bookingNumber, documentType, amountCents);
+    }
+    const allocated = await financeService.allocateInvoiceNumber(db, series.id);
+    if (allocated.status === "allocated") {
+        return allocated.formattedNumber;
+    }
+    return fallbackInvoiceNumber(bookingNumber, documentType, amountCents);
+}
+function pickSchedule(schedules, scheduleId) {
+    if (scheduleId) {
+        return schedules.find((schedule) => schedule.id === scheduleId) ?? null;
+    }
+    return schedules[0] ?? null;
+}
+function pickInvoice(outstandingInvoices, invoiceId) {
+    if (invoiceId) {
+        return outstandingInvoices.find((invoice) => invoice.id === invoiceId) ?? null;
+    }
+    return outstandingInvoices[0] ?? null;
+}
+export async function previewCheckoutCollection(db, bookingId, input, options = {}) {
+    const context = await loadBookingContext(db, bookingId);
+    if (!context)
+        return null;
+    const schedules = await ensurePaymentPlanIfNeeded(db, bookingId, context.schedules, input, options);
+    let paymentSessionTarget = resolvePaymentSessionTarget(input.method, input.stage, input.paymentSessionTarget, options);
+    let documentType = resolveDocumentType(input.method, paymentSessionTarget, options);
+    let selectedSchedule = pickSchedule(schedules, input.scheduleId);
+    let selectedInvoice = pickInvoice(context.outstandingInvoices, input.invoiceId);
+    const requestedAmountCents = normalizeExactAmountCents(input.amountCents);
+    let amountCents = 0;
+    if (requestedAmountCents !== null) {
+        amountCents = requestedAmountCents;
+        if (paymentSessionTarget === "schedule" &&
+            selectedSchedule &&
+            selectedSchedule.amountCents === requestedAmountCents) {
+            selectedInvoice = null;
+        }
+        else {
+            paymentSessionTarget = "invoice";
+            documentType = resolveDocumentType(input.method, paymentSessionTarget, options);
+            selectedInvoice =
+                selectedInvoice && selectedInvoice.balanceDueCents === requestedAmountCents
+                    ? selectedInvoice
+                    : null;
+            selectedSchedule = null;
+        }
+    }
+    else if (paymentSessionTarget === "invoice") {
+        amountCents =
+            selectedInvoice?.balanceDueCents ??
+                selectedSchedule?.amountCents ??
+                context.booking.sellAmountCents ??
+                0;
+    }
+    else if (paymentSessionTarget === "schedule") {
+        amountCents = selectedSchedule?.amountCents ?? context.booking.sellAmountCents ?? 0;
+    }
+    let recommendedAction = "none";
+    if (input.method === "bank_transfer") {
+        recommendedAction = "create_bank_transfer_document";
+    }
+    else if (paymentSessionTarget === "invoice") {
+        recommendedAction = selectedInvoice
+            ? "create_payment_session"
+            : "create_invoice_then_payment_session";
+    }
+    else if (paymentSessionTarget === "schedule") {
+        recommendedAction = "create_payment_session";
+    }
+    return {
+        bookingId,
+        method: input.method,
+        stage: input.stage,
+        paymentSessionTarget,
+        documentType,
+        willCreateDefaultPaymentPlan: context.schedules.length === 0 && schedules.length > 0,
+        selectedSchedule,
+        selectedInvoice,
+        amountCents,
+        currency: context.booking.sellCurrency,
+        recommendedAction,
+    };
+}
+async function createCollectionInvoice(db, context, plan, notes) {
+    const amountCents = plan.amountCents;
+    const issueDate = new Date().toISOString().slice(0, 10);
+    const dueDate = plan.selectedSchedule?.dueDate ?? issueDate;
+    const documentType = plan.documentType ?? "invoice";
+    const invoiceNumber = await allocateDocumentNumber(db, context.booking.bookingNumber, documentType, amountCents);
+    const [invoice] = await db
+        .insert(invoices)
+        .values({
+        invoiceNumber,
+        bookingId: context.booking.id,
+        personId: context.booking.personId,
+        organizationId: context.booking.organizationId,
+        invoiceType: documentType,
+        status: "sent",
+        currency: context.booking.sellCurrency,
+        baseCurrency: context.booking.baseCurrency,
+        fxRateSetId: null,
+        subtotalCents: amountCents,
+        baseSubtotalCents: context.booking.baseSellAmountCents,
+        taxCents: 0,
+        baseTaxCents: null,
+        totalCents: amountCents,
+        baseTotalCents: context.booking.baseSellAmountCents,
+        paidCents: 0,
+        basePaidCents: 0,
+        balanceDueCents: amountCents,
+        baseBalanceDueCents: context.booking.baseSellAmountCents,
+        commissionAmountCents: null,
+        issueDate,
+        dueDate,
+        notes: notes ?? plan.selectedSchedule?.notes ?? null,
+    })
+        .returning();
+    if (!invoice) {
+        throw new Error("Failed to create collection invoice");
+    }
+    await db.insert(invoiceLineItems).values({
+        invoiceId: invoice.id,
+        bookingItemId: plan.selectedSchedule?.bookingItemId ?? null,
+        description: lineDescription(context.booking, plan.selectedSchedule, plan.stage),
+        quantity: 1,
+        unitPriceCents: amountCents,
+        totalCents: amountCents,
+        taxRate: null,
+        sortOrder: 0,
+    });
+    return invoice;
+}
+export async function initiateCheckoutCollection(db, bookingId, input, options = {}, dispatcher, runtime = {}) {
+    const context = await loadBookingContext(db, bookingId);
+    if (!context)
+        return null;
+    const plan = await previewCheckoutCollection(db, bookingId, input, options);
+    if (!plan)
+        return null;
+    if (plan.amountCents <= 0) {
+        throw new Error("No outstanding amount available for collection");
+    }
+    let invoice = plan.selectedInvoice;
+    let paymentSession = null;
+    let invoiceNotification = null;
+    let paymentSessionNotification = null;
+    let bankTransferInstructions = null;
+    let providerStart = null;
+    if (input.method === "bank_transfer") {
+        invoice = await createCollectionInvoice(db, context, plan, input.notes ?? null);
+        bankTransferInstructions = buildBankTransferInstructions(invoice, runtime.bankTransferDetails ?? null, input.notes ?? null);
+        if (dispatcher && input.invoiceNotification) {
+            invoiceNotification = await notificationsService.sendInvoiceNotification(db, dispatcher, invoice.id, input.invoiceNotification);
+        }
+    }
+    else if (plan.paymentSessionTarget === "invoice") {
+        if (!invoice) {
+            invoice = await createCollectionInvoice(db, context, { ...plan, documentType: "invoice" }, input.notes ?? null);
+        }
+        paymentSession = await financeService.createPaymentSessionFromInvoice(db, invoice.id, {
+            ...(input.paymentSession ?? {}),
+            notes: input.notes ?? input.paymentSession?.notes ?? null,
+        });
+        if (!paymentSession) {
+            throw new Error("Failed to create payment session from invoice");
+        }
+        if (dispatcher && input.invoiceNotification) {
+            invoiceNotification = await notificationsService.sendInvoiceNotification(db, dispatcher, invoice.id, input.invoiceNotification);
+        }
+        if (dispatcher && input.paymentSessionNotification) {
+            paymentSessionNotification = await notificationsService.sendPaymentSessionNotification(db, dispatcher, paymentSession.id, input.paymentSessionNotification);
+        }
+    }
+    else {
+        if (!plan.selectedSchedule) {
+            throw new Error("No outstanding payment schedule available for collection");
+        }
+        paymentSession = await financeService.createPaymentSessionFromBookingSchedule(db, plan.selectedSchedule.id, {
+            ...(input.paymentSession ?? {}),
+            notes: input.notes ?? input.paymentSession?.notes ?? null,
+        });
+        if (!paymentSession) {
+            throw new Error("Failed to create payment session from booking schedule");
+        }
+        if (dispatcher && input.paymentSessionNotification) {
+            paymentSessionNotification = await notificationsService.sendPaymentSessionNotification(db, dispatcher, paymentSession.id, input.paymentSessionNotification);
+        }
+    }
+    if (input.startProvider) {
+        if (input.method !== "card") {
+            throw new Error("Provider start is only available for card collections");
+        }
+        if (!paymentSession) {
+            throw new Error("No payment session available for provider start");
+        }
+        const starter = runtime.paymentStarters?.[input.startProvider.provider];
+        if (!starter) {
+            throw new Error(`Payment provider "${input.startProvider.provider}" is not configured`);
+        }
+        providerStart = await starter({
+            db,
+            bookingId,
+            plan,
+            invoice: invoice ?? null,
+            paymentSession,
+            input,
+            startProvider: input.startProvider,
+            bindings: runtime.bindings ?? {},
+        });
+        if (providerStart.paymentSessionId !== paymentSession.id) {
+            const updatedSession = await financeService.getPaymentSessionById(db, providerStart.paymentSessionId);
+            paymentSession = updatedSession ?? paymentSession;
+        }
+        else {
+            const updatedSession = await financeService.getPaymentSessionById(db, paymentSession.id);
+            paymentSession = updatedSession ?? paymentSession;
+        }
+    }
+    return {
+        plan,
+        invoice: invoice ?? null,
+        paymentSession,
+        invoiceNotification,
+        paymentSessionNotification,
+        bankTransferInstructions,
+        providerStart,
+    };
+}
+export async function bootstrapCheckoutCollection(db, input, options = {}, dispatcher, runtime = {}) {
+    const subject = resolveCheckoutSubject(input);
+    const initiated = await initiateCheckoutCollection(db, subject.bookingId, {
+        method: input.method,
+        stage: input.stage,
+        scheduleId: input.scheduleId,
+        invoiceId: input.invoiceId,
+        amountCents: input.amountCents,
+        ensureDefaultPaymentPlan: input.ensureDefaultPaymentPlan,
+        paymentSessionTarget: input.paymentSessionTarget,
+        paymentPlan: input.paymentPlan,
+        paymentSession: input.paymentSession,
+        paymentSessionNotification: input.paymentSessionNotification,
+        invoiceNotification: input.invoiceNotification,
+        startProvider: input.startProvider,
+        notes: input.notes,
+    }, options, dispatcher, runtime);
+    if (!initiated) {
+        return null;
+    }
+    return {
+        bookingId: subject.bookingId,
+        sessionId: subject.sessionId,
+        sourceType: subject.sourceType,
+        intent: resolveCheckoutIntent(input),
+        ...initiated,
+    };
+}
+export async function listBookingReminderRuns(db, bookingId, query) {
+    const where = and(eq(notificationReminderRuns.bookingId, bookingId), ...(query.status ? [eq(notificationReminderRuns.status, query.status)] : []));
+    const [rows, countResult] = await Promise.all([
+        db
+            .select({
+            id: notificationReminderRuns.id,
+            reminderRuleId: notificationReminderRuns.reminderRuleId,
+            targetType: notificationReminderRuns.targetType,
+            targetId: notificationReminderRuns.targetId,
+            bookingId: notificationReminderRuns.bookingId,
+            paymentSessionId: notificationReminderRuns.paymentSessionId,
+            notificationDeliveryId: notificationReminderRuns.notificationDeliveryId,
+            status: notificationReminderRuns.status,
+            recipient: notificationReminderRuns.recipient,
+            scheduledFor: notificationReminderRuns.scheduledFor,
+            processedAt: notificationReminderRuns.processedAt,
+            errorMessage: notificationReminderRuns.errorMessage,
+            createdAt: notificationReminderRuns.createdAt,
+            reminderRuleSlug: notificationReminderRules.slug,
+            reminderRuleName: notificationReminderRules.name,
+            relativeDaysFromDueDate: notificationReminderRules.relativeDaysFromDueDate,
+            channel: notificationReminderRules.channel,
+            ruleProvider: notificationReminderRules.provider,
+            deliveryStatus: notificationDeliveries.status,
+            deliveryProvider: notificationDeliveries.provider,
+        })
+            .from(notificationReminderRuns)
+            .leftJoin(notificationReminderRules, eq(notificationReminderRules.id, notificationReminderRuns.reminderRuleId))
+            .leftJoin(notificationDeliveries, eq(notificationDeliveries.id, notificationReminderRuns.notificationDeliveryId))
+            .where(where)
+            .orderBy(desc(notificationReminderRuns.createdAt))
+            .limit(query.limit)
+            .offset(query.offset),
+        db.select({ count: sql `count(*)::int` }).from(notificationReminderRuns).where(where),
+    ]);
+    return {
+        data: rows.map((row) => ({
+            id: row.id,
+            reminderRuleId: row.reminderRuleId,
+            reminderRuleSlug: row.reminderRuleSlug ?? null,
+            reminderRuleName: row.reminderRuleName ?? null,
+            targetType: row.targetType,
+            targetId: row.targetId,
+            bookingId: row.bookingId ?? null,
+            paymentSessionId: row.paymentSessionId ?? null,
+            notificationDeliveryId: row.notificationDeliveryId ?? null,
+            status: row.status,
+            deliveryStatus: row.deliveryStatus ?? null,
+            channel: row.channel ?? null,
+            provider: row.deliveryProvider ?? row.ruleProvider ?? null,
+            recipient: row.recipient ?? null,
+            scheduledFor: normalizeRequiredDateTime(row.scheduledFor),
+            processedAt: normalizeRequiredDateTime(row.processedAt),
+            errorMessage: row.errorMessage ?? null,
+            relativeDaysFromDueDate: row.relativeDaysFromDueDate ?? null,
+            createdAt: normalizeRequiredDateTime(row.createdAt),
+        })),
+        total: countResult[0]?.count ?? 0,
+        limit: query.limit,
+        offset: query.offset,
+    };
+}