@voyant-travel/finance 0.119.5

package/dist/service-invoice-credit-notes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-invoice-credit-notes.d.ts","sourceRoot":"","sources":["../src/service-invoice-credit-notes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,6BAA6B,EAC7B,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,qBAAqB,CAAA;AAiB5B,eAAO,MAAM,+BAA+B;wBACtB,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBASnD,kBAAkB,aACX,MAAM,QACX,qBAAqB,YAClB,qBAAqB;;;;;;;;;;;;;;;yBA0C1B,kBAAkB,gBACR,MAAM,QACd,qBAAqB,YAClB,qBAAqB;;;;;;;;;;;;;;;gCAkDJ,kBAAkB,gBAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAS9D,kBAAkB,gBACR,MAAM,QACd,6BAA6B,YAC1B,qBAAqB;;;;;;;;;;kBAsDlB,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAS7C,kBAAkB,aACX,MAAM,UACT,MAAM,QACR,sBAAsB;;;;;;;CAuB/B,CAAA"}

package/dist/service-invoice-credit-notes.js

@@ -0,0 +1,142 @@
+import { appendActionLedgerMutation, asc, buildCreditNoteCreationActionLedgerInput, buildCreditNoteLineItemCreateActionLedgerInput, buildCreditNoteUpdateActionLedgerInput, creditNoteLineItems, creditNotes, desc, eq, financeNotes, invoices, resolveCreditNoteUpdateData, resolveFxMoneyBaseAmount, } from "./service-shared.js";
+export const financeInvoiceCreditNoteService = {
+    listCreditNotes(db, invoiceId) {
+        return db
+            .select()
+            .from(creditNotes)
+            .where(eq(creditNotes.invoiceId, invoiceId))
+            .orderBy(desc(creditNotes.createdAt));
+    },
+    async createCreditNote(db, invoiceId, data, runtime = {}) {
+        const [invoice] = await db.select().from(invoices).where(eq(invoices.id, invoiceId)).limit(1);
+        if (!invoice) {
+            return null;
+        }
+        const creditNoteData = await resolveFxMoneyBaseAmount(db, data, {
+            ...runtime,
+            targetBaseCurrency: invoice.currency,
+            fallbackFxRateSetId: invoice.fxRateSetId ?? null,
+            date: new Date(),
+        });
+        return db.transaction(async (tx) => {
+            const [row] = await tx
+                .insert(creditNotes)
+                .values({ ...creditNoteData, invoiceId })
+                .returning();
+            if (row && runtime.actionLedgerContext) {
+                await appendActionLedgerMutation(tx, await buildCreditNoteCreationActionLedgerInput(runtime.actionLedgerContext, {
+                    invoice,
+                    creditNote: row,
+                }, {
+                    authorizationSource: runtime.actionLedgerAuthorizationSource,
+                }));
+            }
+            return row;
+        });
+    },
+    async updateCreditNote(db, creditNoteId, data, runtime = {}) {
+        const updateData = await resolveCreditNoteUpdateData(db, creditNoteId, data, runtime);
+        if (!updateData)
+            return null;
+        const updateCreditNoteRow = async (writer) => {
+            const [row] = await writer
+                .update(creditNotes)
+                .set({ ...updateData, updatedAt: new Date() })
+                .where(eq(creditNotes.id, creditNoteId))
+                .returning();
+            if (!row) {
+                return null;
+            }
+            const [invoice] = await writer
+                .select()
+                .from(invoices)
+                .where(eq(invoices.id, row.invoiceId))
+                .limit(1);
+            return invoice ? { invoice, creditNote: row } : null;
+        };
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            const result = await db.transaction(async (tx) => {
+                const updated = await updateCreditNoteRow(tx);
+                if (updated) {
+                    await appendActionLedgerMutation(tx, buildCreditNoteUpdateActionLedgerInput(actionLedgerContext, { ...updated, changes: updateData }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                }
+                return updated;
+            });
+            return result?.creditNote ?? null;
+        }
+        return (await updateCreditNoteRow(db))?.creditNote ?? null;
+    },
+    listCreditNoteLineItems(db, creditNoteId) {
+        return db
+            .select()
+            .from(creditNoteLineItems)
+            .where(eq(creditNoteLineItems.creditNoteId, creditNoteId))
+            .orderBy(asc(creditNoteLineItems.sortOrder));
+    },
+    async createCreditNoteLineItem(db, creditNoteId, data, runtime = {}) {
+        const createLineItem = async (writer) => {
+            const [creditNote] = await writer
+                .select()
+                .from(creditNotes)
+                .where(eq(creditNotes.id, creditNoteId))
+                .limit(1);
+            if (!creditNote) {
+                return null;
+            }
+            const [invoice] = await writer
+                .select()
+                .from(invoices)
+                .where(eq(invoices.id, creditNote.invoiceId))
+                .limit(1);
+            if (!invoice) {
+                return null;
+            }
+            const [row] = await writer
+                .insert(creditNoteLineItems)
+                .values({ ...data, creditNoteId })
+                .returning();
+            return row ? { invoice, creditNote, lineItem: row } : null;
+        };
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            const result = await db.transaction(async (tx) => {
+                const created = await createLineItem(tx);
+                if (created) {
+                    await appendActionLedgerMutation(tx, buildCreditNoteLineItemCreateActionLedgerInput(actionLedgerContext, created, {
+                        authorizationSource: runtime.actionLedgerAuthorizationSource,
+                    }));
+                }
+                return created;
+            });
+            return result?.lineItem ?? null;
+        }
+        return (await createLineItem(db))?.lineItem ?? null;
+    },
+    listNotes(db, invoiceId) {
+        return db
+            .select()
+            .from(financeNotes)
+            .where(eq(financeNotes.invoiceId, invoiceId))
+            .orderBy(financeNotes.createdAt);
+    },
+    async createNote(db, invoiceId, userId, data) {
+        const [invoice] = await db
+            .select({ id: invoices.id })
+            .from(invoices)
+            .where(eq(invoices.id, invoiceId))
+            .limit(1);
+        if (!invoice) {
+            return null;
+        }
+        const [row] = await db
+            .insert(financeNotes)
+            .values({
+            invoiceId,
+            authorId: userId,
+            content: data.content,
+        })
+            .returning();
+        return row;
+    },
+};

package/dist/service-invoice-from-booking.d.ts

@@ -0,0 +1,41 @@
+import type { CreateInvoiceFromBookingInput, FinanceServiceRuntime, InvoiceFromBookingData, PostgresJsDatabase } from "./service-shared.js";
+export declare const financeInvoiceFromBookingService: {
+    createInvoiceFromBooking(db: PostgresJsDatabase, data: CreateInvoiceFromBookingInput, bookingData: InvoiceFromBookingData, runtime?: FinanceServiceRuntime): Promise<{
+        subtotalCents: number;
+        currency: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        taxRegimeId: string | null;
+        taxCents: number;
+        totalCents: number;
+        status: "void" | "paid" | "draft" | "pending_external_allocation" | "issued" | "partially_paid" | "overdue";
+        bookingId: string;
+        notes: string | null;
+        templateId: string | null;
+        dueDate: string;
+        invoiceNumber: string;
+        invoiceType: "invoice" | "proforma" | "credit_note";
+        convertedFromInvoiceId: string | null;
+        seriesId: string | null;
+        sequence: number | null;
+        language: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        baseCurrency: string | null;
+        fxRateSetId: string | null;
+        baseSubtotalCents: number | null;
+        baseTaxCents: number | null;
+        baseTotalCents: number | null;
+        paidCents: number;
+        basePaidCents: number | null;
+        balanceDueCents: number;
+        baseBalanceDueCents: number | null;
+        commissionPercent: number | null;
+        commissionAmountCents: number | null;
+        issueDate: string;
+        voidedAt: Date | null;
+        voidReason: string | null;
+    } | null>;
+};
+//# sourceMappingURL=service-invoice-from-booking.d.ts.map

package/dist/service-invoice-from-booking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-invoice-from-booking.d.ts","sourceRoot":"","sources":["../src/service-invoice-from-booking.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,6BAA6B,EAC7B,qBAAqB,EACrB,sBAAsB,EACtB,kBAAkB,EACnB,MAAM,qBAAqB,CAAA;AAsG5B,eAAO,MAAM,gCAAgC;iCAErC,kBAAkB,QAChB,6BAA6B,eACtB,sBAAsB,YAC1B,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4PjC,CAAA"}

package/dist/service-invoice-from-booking.js

@@ -0,0 +1,267 @@
+import { financeInvoiceNumberingService } from "./service-invoice-numbering.js";
+import { assertInvoiceFromBookingOverrideTotals, bookingItemCommissions, bookingItemTaxLines, bookingItemToInvoiceLine, bookingPaymentScheduleToInvoiceLine, eq, InvoiceFromBookingValidationError, InvoiceLineItemsPersistenceError, InvoiceNumberAllocationError, InvoiceNumberConflictError, invoiceExternalRefs, invoiceFromBookingExternalRefValues, invoiceFromBookingOverrideLineItems, invoiceLineItems, invoiceScopeForType, invoices, isInvoiceNumberUniqueConstraintError, normalizeCurrencyCode, or, pendingExternalInvoiceNumber, resolveBookingInvoiceBaseAmount, resolveFxMoneyBaseAmount, resolveInvoiceFromBookingDueDate, resolveInvoiceLineDescriptions, resolvePaymentScheduleDisplayItem, } from "./service-shared.js";
+async function resolveInvoiceNumberForBooking(db, data) {
+    const scope = invoiceScopeForType(data.invoiceType);
+    if (data.invoiceNumber) {
+        return {
+            invoiceNumber: data.invoiceNumber,
+            seriesId: data.seriesId ?? null,
+            sequence: null,
+            status: "draft",
+        };
+    }
+    const series = data.seriesId
+        ? await financeInvoiceNumberingService.getInvoiceNumberSeriesById(db, data.seriesId)
+        : await financeInvoiceNumberingService.resolveDefaultInvoiceNumberSeries(db, scope);
+    if (!series) {
+        throw new InvoiceNumberAllocationError(data.seriesId ? "invoice_number_series_not_found" : "no_active_series_for_scope", { scope, seriesId: data.seriesId });
+    }
+    if (!series.active) {
+        throw new InvoiceNumberAllocationError("invoice_number_series_inactive", {
+            scope,
+            seriesId: series.id,
+        });
+    }
+    if (series.scope !== scope) {
+        throw new InvoiceNumberAllocationError("invoice_number_series_scope_mismatch", {
+            scope,
+            seriesId: series.id,
+        });
+    }
+    if (series.externalProvider) {
+        return {
+            invoiceNumber: pendingExternalInvoiceNumber(scope),
+            seriesId: series.id,
+            sequence: null,
+            status: "pending_external_allocation",
+        };
+    }
+    const allocated = await financeInvoiceNumberingService.allocateInvoiceNumber(db, series.id);
+    if (allocated.status === "not_found") {
+        throw new InvoiceNumberAllocationError("invoice_number_series_not_found", {
+            scope,
+            seriesId: series.id,
+        });
+    }
+    if (allocated.status === "inactive") {
+        throw new InvoiceNumberAllocationError("invoice_number_series_inactive", {
+            scope,
+            seriesId: series.id,
+        });
+    }
+    return {
+        invoiceNumber: allocated.formattedNumber,
+        seriesId: allocated.seriesId,
+        sequence: allocated.sequence,
+        status: "draft",
+    };
+}
+export const financeInvoiceFromBookingService = {
+    async createInvoiceFromBooking(db, data, bookingData, runtime = {}) {
+        const { booking, items, paymentSchedule } = bookingData;
+        const invoiceDueDate = await resolveInvoiceFromBookingDueDate(data, bookingData, runtime);
+        const requestedCurrency = normalizeCurrencyCode(data.currency);
+        const bookingSellCurrency = normalizeCurrencyCode(booking.sellCurrency) ?? booking.sellCurrency;
+        const invoiceCurrency = requestedCurrency ?? normalizeCurrencyCode(paymentSchedule?.currency) ?? bookingSellCurrency;
+        const requestedBaseCurrency = normalizeCurrencyCode(data.baseCurrency);
+        const hasCrossCurrencyOverride = requestedCurrency !== null && requestedCurrency !== bookingSellCurrency;
+        if (hasCrossCurrencyOverride &&
+            (!requestedBaseCurrency || requestedBaseCurrency !== bookingSellCurrency)) {
+            throw new InvoiceFromBookingValidationError("Cross-currency invoice overrides require baseCurrency to match the booking sell currency", {
+                currency: invoiceCurrency,
+                baseCurrency: requestedBaseCurrency,
+                bookingSellCurrency,
+            });
+        }
+        const overrideLineItems = data.lineItems
+            ? invoiceFromBookingOverrideLineItems(data.lineItems)
+            : null;
+        if (hasCrossCurrencyOverride && !overrideLineItems) {
+            throw new InvoiceFromBookingValidationError("Cross-currency invoice overrides require replacement line items", {
+                currency: invoiceCurrency,
+                baseCurrency: requestedBaseCurrency,
+                bookingSellCurrency,
+                fields: ["lineItems"],
+            });
+        }
+        const shouldUseBookingItems = overrideLineItems === null && !paymentSchedule;
+        const invoiceItems = shouldUseBookingItems ? items : [];
+        const itemIds = invoiceItems.map((item) => item.id);
+        const taxes = itemIds.length === 0
+            ? []
+            : await db
+                .select()
+                .from(bookingItemTaxLines)
+                .where(or(...itemIds.map((id) => eq(bookingItemTaxLines.bookingItemId, id))));
+        const commissions = itemIds.length === 0
+            ? []
+            : await db
+                .select()
+                .from(bookingItemCommissions)
+                .where(or(...itemIds.map((id) => eq(bookingItemCommissions.bookingItemId, id))));
+        const taxesByBookingItemId = new Map();
+        for (const tax of taxes) {
+            const existing = taxesByBookingItemId.get(tax.bookingItemId) ?? [];
+            existing.push(tax);
+            taxesByBookingItemId.set(tax.bookingItemId, existing);
+        }
+        const scheduleItem = paymentSchedule
+            ? resolvePaymentScheduleDisplayItem(paymentSchedule, items)
+            : undefined;
+        const paymentScheduleLineDescriptionFormat = data.paymentScheduleLineDescriptionFormat ??
+            runtime.paymentScheduleLineDescriptionFormat ??
+            "schedule_first";
+        const resolvedLineItems = overrideLineItems ??
+            (paymentSchedule
+                ? [
+                    bookingPaymentScheduleToInvoiceLine(booking, paymentSchedule, scheduleItem, paymentScheduleLineDescriptionFormat),
+                ]
+                : invoiceItems.length > 0
+                    ? invoiceItems.map((item, sortOrder) => ({
+                        ...bookingItemToInvoiceLine(item, taxesByBookingItemId.get(item.id) ?? [], sortOrder),
+                    }))
+                    : [
+                        {
+                            bookingItemId: null,
+                            bookingPaymentScheduleId: null,
+                            description: `Booking ${booking.bookingNumber}`,
+                            quantity: 1,
+                            unitPriceCents: booking.sellAmountCents ?? 0,
+                            totalCents: booking.sellAmountCents ?? 0,
+                            taxAmountCents: 0,
+                            taxRate: null,
+                            sortOrder: 0,
+                        },
+                    ]);
+        const lineItems = await resolveInvoiceLineDescriptions(resolvedLineItems, {
+            booking,
+            paymentSchedule,
+            items,
+            descriptionResolver: runtime.descriptionResolver,
+        });
+        const grossLineTotalCents = lineItems.reduce((sum, line) => sum + line.totalCents, 0);
+        const includedTaxCents = overrideLineItems
+            ? 0
+            : taxes.reduce((sum, tax) => {
+                if (tax.scope === "withheld" || !tax.includedInPrice)
+                    return sum;
+                return sum + tax.amountCents;
+            }, 0);
+        const excludedTaxCents = overrideLineItems
+            ? overrideLineItems.reduce((sum, line) => sum + line.taxAmountCents, 0)
+            : taxes.reduce((sum, tax) => {
+                if (tax.scope === "withheld" || tax.includedInPrice)
+                    return sum;
+                return sum + tax.amountCents;
+            }, 0);
+        const subtotalCents = Math.max(0, grossLineTotalCents - includedTaxCents);
+        const taxCents = includedTaxCents + excludedTaxCents;
+        const totalCents = subtotalCents + taxCents;
+        assertInvoiceFromBookingOverrideTotals(data, { subtotalCents, taxCents, totalCents });
+        const commissionAmountCents = overrideLineItems
+            ? 0
+            : commissions.reduce((sum, commission) => {
+                return sum + (commission.amountCents ?? 0);
+            }, 0);
+        // The `ck_invoices_base_currency_amounts` constraint requires
+        // that whenever ANY base_*_cents column is non-null, base_currency
+        // must be set too. Resolve the base side once and propagate nulls
+        // consistently when no booking/runtime base currency is available.
+        const bookingBaseAmountCents = paymentSchedule
+            ? resolveBookingInvoiceBaseAmount(booking, invoiceCurrency, paymentSchedule.amountCents)
+            : (booking.baseSellAmountCents ?? null);
+        const invoiceBaseCurrency = requestedBaseCurrency ?? booking.baseCurrency ?? null;
+        const invoiceFxRateSetId = data.fxRateSetId ?? booking.fxRateSetId ?? null;
+        const resolvedInvoiceBase = await resolveFxMoneyBaseAmount(db, {
+            amountCents: totalCents,
+            currency: invoiceCurrency,
+            baseCurrency: invoiceBaseCurrency,
+            baseAmountCents: hasCrossCurrencyOverride ? null : bookingBaseAmountCents,
+            fxRateSetId: invoiceFxRateSetId,
+        }, {
+            ...runtime,
+            targetBaseCurrency: invoiceBaseCurrency,
+            fallbackFxRateSetId: invoiceFxRateSetId,
+            date: data.issueDate,
+            setBaseCurrencyWhenUnresolved: Boolean(invoiceBaseCurrency),
+        });
+        const resolvedBaseCurrency = resolvedInvoiceBase.baseCurrency ?? null;
+        const invoiceBaseAmountCents = resolvedInvoiceBase.baseAmountCents ?? null;
+        const hasBaseCurrency = Boolean(resolvedBaseCurrency);
+        if (hasCrossCurrencyOverride && invoiceBaseAmountCents === null) {
+            throw new InvoiceFromBookingValidationError("Cross-currency invoice overrides require a resolvable base total", {
+                currency: invoiceCurrency,
+                baseCurrency: requestedBaseCurrency,
+                fxRateSetId: invoiceFxRateSetId,
+            });
+        }
+        const numberAssignment = await resolveInvoiceNumberForBooking(db, data);
+        try {
+            return await db.transaction(async (tx) => {
+                const [invoice] = await tx
+                    .insert(invoices)
+                    .values({
+                    invoiceNumber: numberAssignment.invoiceNumber,
+                    invoiceType: data.invoiceType,
+                    seriesId: numberAssignment.seriesId,
+                    sequence: numberAssignment.sequence,
+                    bookingId: booking.id,
+                    personId: booking.personId,
+                    organizationId: booking.organizationId,
+                    status: numberAssignment.status,
+                    currency: invoiceCurrency,
+                    baseCurrency: resolvedBaseCurrency,
+                    fxRateSetId: resolvedInvoiceBase.fxRateSetId ?? null,
+                    subtotalCents,
+                    baseSubtotalCents: hasBaseCurrency ? invoiceBaseAmountCents : null,
+                    taxCents,
+                    baseTaxCents: null,
+                    totalCents,
+                    baseTotalCents: hasBaseCurrency ? invoiceBaseAmountCents : null,
+                    paidCents: 0,
+                    basePaidCents: hasBaseCurrency ? 0 : null,
+                    balanceDueCents: totalCents,
+                    baseBalanceDueCents: hasBaseCurrency ? invoiceBaseAmountCents : null,
+                    commissionAmountCents: commissionAmountCents > 0 ? commissionAmountCents : null,
+                    issueDate: data.issueDate,
+                    dueDate: invoiceDueDate,
+                    notes: data.notes ?? null,
+                })
+                    .returning();
+                if (!invoice) {
+                    return null;
+                }
+                if (data.externalRefs?.length) {
+                    await tx
+                        .insert(invoiceExternalRefs)
+                        .values(invoiceFromBookingExternalRefValues(invoice.id, data.externalRefs));
+                }
+                const lineItemValues = lineItems.map((line) => ({
+                    invoiceId: invoice.id,
+                    bookingItemId: line.bookingItemId,
+                    bookingPaymentScheduleId: line.bookingPaymentScheduleId,
+                    description: line.description,
+                    quantity: line.quantity,
+                    unitPriceCents: line.unitPriceCents,
+                    totalCents: line.totalCents,
+                    taxRate: line.taxRate,
+                    sortOrder: line.sortOrder,
+                }));
+                const insertedLineItems = await tx
+                    .insert(invoiceLineItems)
+                    .values(lineItemValues)
+                    .returning({ id: invoiceLineItems.id });
+                if (insertedLineItems.length !== lineItemValues.length) {
+                    throw new InvoiceLineItemsPersistenceError(invoice.id, lineItemValues.length, insertedLineItems.length);
+                }
+                return invoice;
+            });
+        }
+        catch (error) {
+            if (isInvoiceNumberUniqueConstraintError(error)) {
+                throw new InvoiceNumberConflictError(numberAssignment.invoiceNumber);
+            }
+            throw error;
+        }
+    },
+};