@voyant-travel/finance 0.119.5

package/dist/checkout-service.js

@@ -0,0 +1,324 @@
+import { bookingItems, bookings, bookingTravelers } from "@voyant-travel/bookings";
+import { and, asc, desc, eq, gt, inArray } from "drizzle-orm";
+import { buildBankTransferInstructions, defaultPaymentPlan, fallbackInvoiceNumber, lineDescription, normalizeExactAmountCents, OUTSTANDING_INVOICE_STATUSES, OUTSTANDING_SCHEDULE_STATUSES, resolveCheckoutIntent, resolveCheckoutSubject, resolveDocumentType, resolvePaymentSessionTarget, } from "./checkout-service-plan.js";
+import { bookingPaymentSchedules, invoiceLineItems, invoiceNumberSeries, invoices, } from "./schema.js";
+import { financeService } from "./service.js";
+export { resolvePaymentSessionTarget, } from "./checkout-service-plan.js";
+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: "issued",
+        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 = {}, 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 (runtime.notificationDispatcher?.sendInvoiceNotification && input.invoiceNotification) {
+            invoiceNotification = await runtime.notificationDispatcher.sendInvoiceNotification(db, invoice.id, withPaymentLinkBaseUrl(input.invoiceNotification, runtime.publicCheckoutBaseUrl));
+        }
+    }
+    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 (runtime.notificationDispatcher?.sendInvoiceNotification && input.invoiceNotification) {
+            invoiceNotification = await runtime.notificationDispatcher.sendInvoiceNotification(db, invoice.id, withPaymentLinkBaseUrl(input.invoiceNotification, runtime.publicCheckoutBaseUrl));
+        }
+        if (runtime.notificationDispatcher?.sendPaymentSessionNotification &&
+            input.paymentSessionNotification) {
+            paymentSessionNotification =
+                await runtime.notificationDispatcher.sendPaymentSessionNotification(db, paymentSession.id, withPaymentLinkBaseUrl(input.paymentSessionNotification, runtime.publicCheckoutBaseUrl));
+        }
+    }
+    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 (runtime.notificationDispatcher?.sendPaymentSessionNotification &&
+            input.paymentSessionNotification) {
+            paymentSessionNotification =
+                await runtime.notificationDispatcher.sendPaymentSessionNotification(db, paymentSession.id, withPaymentLinkBaseUrl(input.paymentSessionNotification, runtime.publicCheckoutBaseUrl));
+        }
+    }
+    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,
+    };
+}
+function withPaymentLinkBaseUrl(input, publicCheckoutBaseUrl) {
+    if (input.paymentLinkBaseUrl || !publicCheckoutBaseUrl)
+        return input;
+    return { ...input, paymentLinkBaseUrl: publicCheckoutBaseUrl };
+}
+export async function bootstrapCheckoutCollection(db, input, options = {}, 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, runtime);
+    if (!initiated) {
+        return null;
+    }
+    return {
+        bookingId: subject.bookingId,
+        sessionId: subject.sessionId,
+        sourceType: subject.sourceType,
+        intent: resolveCheckoutIntent(input),
+        ...initiated,
+    };
+}