@voyantjs/finance 0.3.1 → 0.4.1

package/dist/service-documents.js

@@ -0,0 +1,226 @@
+import { renderPdfDocument } from "@voyantjs/utils/pdf-renderer";
+import { and, desc, eq } from "drizzle-orm";
+import { invoiceTemplates, } from "./schema.js";
+import { financeService, renderInvoiceBody } from "./service.js";
+function defaultInvoiceDocumentMimeType(format) {
+    switch (format) {
+        case "html":
+            return "text/html; charset=utf-8";
+        case "json":
+            return "application/json; charset=utf-8";
+        case "xml":
+            return "application/xml; charset=utf-8";
+        default:
+            return "application/pdf";
+    }
+}
+function encodeStringBody(value) {
+    return new TextEncoder().encode(value);
+}
+function getBodySize(body) {
+    if (body instanceof Uint8Array)
+        return body.byteLength;
+    if (body instanceof ArrayBuffer)
+        return body.byteLength;
+    return body.size;
+}
+function toUploadMetadata(metadata) {
+    const entries = Object.entries(metadata ?? {}).filter(([, value]) => ["string", "number", "boolean"].includes(typeof value));
+    return entries.length > 0
+        ? Object.fromEntries(entries.map(([key, value]) => [key, String(value)]))
+        : undefined;
+}
+export function defaultStorageBackedInvoiceDocumentSerializer(context) {
+    switch (context.targetFormat) {
+        case "html":
+            return {
+                body: encodeStringBody(context.renderedBody),
+                format: "html",
+                language: context.language,
+                metadata: { renderedBodyFormat: context.renderedBodyFormat },
+            };
+        case "json":
+            return {
+                body: encodeStringBody(JSON.stringify(context.variables, null, 2)),
+                format: "json",
+                language: context.language,
+                metadata: { renderedBodyFormat: context.renderedBodyFormat },
+            };
+        case "xml":
+            return {
+                body: encodeStringBody(context.renderedBody),
+                format: "xml",
+                language: context.language,
+                metadata: { renderedBodyFormat: context.renderedBodyFormat },
+            };
+        default:
+            return defaultPdfInvoiceDocumentSerializer(context);
+    }
+}
+export async function defaultPdfInvoiceDocumentSerializer(context) {
+    const body = await renderPdfDocument({
+        title: `Invoice ${context.invoice.id}`,
+        content: context.renderedBody,
+        format: context.renderedBodyFormat === "lexical_json"
+            ? "lexical_json"
+            : context.renderedBodyFormat === "html"
+                ? "html"
+                : "markdown",
+        metadataLines: [
+            `Invoice ID: ${context.invoice.id}`,
+            ...(context.language ? [`Language: ${context.language}`] : []),
+        ],
+    });
+    return {
+        body,
+        format: "pdf",
+        language: context.language,
+        metadata: {
+            renderedBodyFormat: context.renderedBodyFormat,
+            renderer: "voyant-basic-pdf",
+        },
+    };
+}
+export function createStorageBackedInvoiceDocumentGenerator(options) {
+    const serializer = options.serializer ?? defaultStorageBackedInvoiceDocumentSerializer;
+    return async (context) => {
+        const upload = await serializer(context);
+        const format = upload.format ?? context.targetFormat;
+        const keyPrefix = typeof options.keyPrefix === "function"
+            ? await options.keyPrefix(context)
+            : (options.keyPrefix ?? `invoices/${context.invoice.id}`);
+        const key = upload.key?.trim() || `${keyPrefix.replace(/\/$/, "")}/rendition.${format}`;
+        const uploaded = await options.storage.upload(upload.body, {
+            key,
+            contentType: defaultInvoiceDocumentMimeType(format),
+            metadata: toUploadMetadata(upload.metadata),
+        });
+        const downloadUrl = uploaded.url ||
+            (options.signedUrlExpiresIn
+                ? await options.storage.signedUrl(uploaded.key, options.signedUrlExpiresIn)
+                : "");
+        return {
+            format,
+            storageKey: uploaded.key,
+            fileSize: getBodySize(upload.body),
+            language: upload.language ?? context.language,
+            metadata: {
+                ...(upload.metadata ?? {}),
+                storageProvider: options.storage.name,
+                ...(uploaded.url ? { url: uploaded.url } : {}),
+                ...(downloadUrl ? { downloadUrl } : {}),
+            },
+        };
+    };
+}
+export function createPdfInvoiceDocumentGenerator(options) {
+    return createStorageBackedInvoiceDocumentGenerator({
+        ...options,
+        serializer: defaultPdfInvoiceDocumentSerializer,
+    });
+}
+async function prepareInvoiceDocument(db, invoiceId, input) {
+    const invoice = await financeService.getInvoiceById(db, invoiceId);
+    if (!invoice) {
+        return { status: "not_found" };
+    }
+    let templateId = input.templateId ?? invoice.templateId ?? null;
+    if (!templateId) {
+        const [defaultTemplate] = await db
+            .select()
+            .from(invoiceTemplates)
+            .where(and(eq(invoiceTemplates.isDefault, true), eq(invoiceTemplates.active, true)))
+            .orderBy(desc(invoiceTemplates.updatedAt))
+            .limit(1);
+        templateId = defaultTemplate?.id ?? null;
+    }
+    const [template, lineItems, paymentRows] = await Promise.all([
+        templateId ? financeService.getInvoiceTemplateById(db, templateId) : Promise.resolve(null),
+        financeService.listInvoiceLineItems(db, invoiceId),
+        financeService.listPayments(db, invoiceId),
+    ]);
+    const renderedBodyFormat = template?.bodyFormat ?? "html";
+    const variables = {
+        invoice,
+        lineItems,
+        payments: paymentRows,
+    };
+    const renderedBody = template
+        ? renderInvoiceBody(template.body, template.bodyFormat, variables)
+        : JSON.stringify(variables);
+    return {
+        status: "ready",
+        invoice,
+        template,
+        lineItems,
+        payments: paymentRows,
+        renderedBody,
+        renderedBodyFormat,
+        variables,
+        targetFormat: input.format,
+        language: input.language ?? invoice.language ?? template?.language ?? null,
+    };
+}
+export const financeDocumentsService = {
+    async generateInvoiceDocument(db, invoiceId, input, runtime) {
+        const prepared = await prepareInvoiceDocument(db, invoiceId, input);
+        if (prepared.status === "not_found") {
+            return { status: "not_found" };
+        }
+        let artifact;
+        try {
+            artifact = await runtime.generator({
+                db,
+                invoice: prepared.invoice,
+                template: prepared.template,
+                lineItems: prepared.lineItems,
+                payments: prepared.payments,
+                renderedBody: prepared.renderedBody,
+                renderedBodyFormat: prepared.renderedBodyFormat,
+                variables: prepared.variables,
+                bindings: runtime.bindings ?? {},
+                targetFormat: prepared.targetFormat,
+                language: prepared.language,
+            });
+        }
+        catch {
+            return { status: "generator_failed" };
+        }
+        if (input.replaceExisting) {
+            const existing = await financeService.listInvoiceRenditions(db, invoiceId);
+            for (const rendition of existing) {
+                if (rendition.format === (artifact.format ?? prepared.targetFormat) &&
+                    rendition.status !== "stale") {
+                    await financeService.updateInvoiceRendition(db, rendition.id, { status: "stale" });
+                }
+            }
+        }
+        const rendition = await financeService.createInvoiceRendition(db, invoiceId, {
+            templateId: prepared.template?.id ?? null,
+            format: artifact.format ?? prepared.targetFormat,
+            status: "ready",
+            storageKey: artifact.storageKey ?? null,
+            fileSize: artifact.fileSize ?? null,
+            checksum: artifact.checksum ?? null,
+            language: artifact.language ?? prepared.language ?? null,
+            generatedAt: new Date().toISOString(),
+            metadata: {
+                ...(artifact.metadata ?? {}),
+                renderedBodyFormat: prepared.renderedBodyFormat,
+            },
+        });
+        if (!rendition) {
+            return { status: "not_found" };
+        }
+        return {
+            status: "generated",
+            invoiceId: prepared.invoice.id,
+            renderedBodyFormat: prepared.renderedBodyFormat,
+            renderedBody: prepared.renderedBody,
+            rendition,
+        };
+    },
+    async regenerateInvoiceDocument(db, invoiceId, input, runtime) {
+        return this.generateInvoiceDocument(db, invoiceId, input, runtime);
+    },
+};

package/dist/service-public.d.ts

@@ -1,7 +1,8 @@
 import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
-import type { PublicBookingFinanceDocuments, PublicPaymentOptionsQuery, PublicStartPaymentSessionInput, PublicValidateVoucherInput } from "./validation-public.js";
+import type { PublicBookingFinanceDocuments, PublicBookingFinancePayments, PublicFinanceDocumentLookup, PublicPaymentOptionsQuery, PublicStartPaymentSessionInput, PublicValidateVoucherInput } from "./validation-public.js";
 export declare const publicFinanceService: {
     getBookingDocuments(db: PostgresJsDatabase, bookingId: string): Promise<PublicBookingFinanceDocuments | null>;
+    getDocumentByReference(db: PostgresJsDatabase, reference: string): Promise<PublicFinanceDocumentLookup | null>;
     getBookingPaymentOptions(db: PostgresJsDatabase, bookingId: string, query: PublicPaymentOptionsQuery): Promise<{
         bookingId: string;
         accounts: {
@@ -42,6 +43,7 @@ export declare const publicFinanceService: {
             targetId: string | null;
         } | null;
     } | null>;
+    getBookingPayments(db: PostgresJsDatabase, bookingId: string): Promise<PublicBookingFinancePayments | null>;
     getPaymentSession(db: PostgresJsDatabase, sessionId: string): Promise<{
         id: string;
         targetType: "other" | "booking" | "order" | "invoice" | "booking_payment_schedule" | "booking_guarantee";

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

@@ -1 +1 @@
-{"version":3,"file":"service-public.d.ts","sourceRoot":"","sources":["../src/service-public.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAUjE,OAAO,KAAK,EACV,6BAA6B,EAC7B,yBAAyB,EACzB,8BAA8B,EAC9B,0BAA0B,EAC3B,MAAM,wBAAwB,CAAA;AA4H/B,eAAO,MAAM,oBAAoB;4BAEzB,kBAAkB,aACX,MAAM,GAChB,OAAO,CAAC,6BAA6B,GAAG,IAAI,CAAC;iCAqE1C,kBAAkB,aACX,MAAM,SACV,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAmHN,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAM3D,kBAAkB,aACX,MAAM,cACL,MAAM,SACX,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;4CA4BjC,kBAAkB,aACX,MAAM,eACJ,MAAM,SACZ,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAuBjC,kBAAkB,aACX,MAAM,SACV,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAMb,kBAAkB,SAAS,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8FhF,CAAA"}
+{"version":3,"file":"service-public.d.ts","sourceRoot":"","sources":["../src/service-public.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAWjE,OAAO,KAAK,EACV,6BAA6B,EAC7B,4BAA4B,EAE5B,2BAA2B,EAC3B,yBAAyB,EACzB,8BAA8B,EAC9B,0BAA0B,EAC3B,MAAM,wBAAwB,CAAA;AA4J/B,eAAO,MAAM,oBAAoB;4BAEzB,kBAAkB,aACX,MAAM,GAChB,OAAO,CAAC,6BAA6B,GAAG,IAAI,CAAC;+BA2C1C,kBAAkB,aACX,MAAM,GAChB,OAAO,CAAC,2BAA2B,GAAG,IAAI,CAAC;iCA0CxC,kBAAkB,aACX,MAAM,SACV,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAoH5B,kBAAkB,aACX,MAAM,GAChB,OAAO,CAAC,4BAA4B,GAAG,IAAI,CAAC;0BA2DnB,kBAAkB,aAAa,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;2CAM3D,kBAAkB,aACX,MAAM,cACL,MAAM,SACX,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;4CA4BjC,kBAAkB,aACX,MAAM,eACJ,MAAM,SACZ,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAuBjC,kBAAkB,aACX,MAAM,SACV,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAMb,kBAAkB,SAAS,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8FhF,CAAA"}

package/dist/service-public.js

@@ -1,6 +1,6 @@
 import { bookings } from "@voyantjs/bookings/schema";
 import { and, asc, desc, eq, or, sql } from "drizzle-orm";
-import { bookingGuarantees, bookingPaymentSchedules, invoiceRenditions, invoices, paymentInstruments, } from "./schema.js";
+import { bookingGuarantees, bookingPaymentSchedules, invoiceRenditions, invoices, paymentInstruments, payments, } from "./schema.js";
 import { financeService } from "./service.js";
 function normalizeDateTime(value) {
     if (!value) {
@@ -105,6 +105,31 @@ function toPublicPaymentSession(session) {
         failureMessage: session.failureMessage ?? null,
     };
 }
+function mapInvoiceDocument(invoice, renditions) {
+    const selectedRendition = renditions.find((rendition) => rendition.status === "ready") ?? renditions[0] ?? null;
+    const metadata = getMetadataRecord(selectedRendition?.metadata ?? null);
+    const downloadUrl = getMetadataDownloadUrl(metadata) ?? maybeUrl(selectedRendition?.storageKey ?? null);
+    return {
+        invoiceId: invoice.id,
+        invoiceNumber: invoice.invoiceNumber,
+        invoiceType: invoice.invoiceType,
+        invoiceStatus: invoice.status,
+        currency: invoice.currency,
+        totalCents: invoice.totalCents,
+        paidCents: invoice.paidCents,
+        balanceDueCents: invoice.balanceDueCents,
+        issueDate: invoice.issueDate,
+        dueDate: invoice.dueDate,
+        renditionId: selectedRendition?.id ?? null,
+        documentStatus: selectedRendition?.status ?? "missing",
+        format: selectedRendition?.format ?? null,
+        language: selectedRendition?.language ?? null,
+        generatedAt: normalizeDateTime(selectedRendition?.generatedAt),
+        fileSize: selectedRendition?.fileSize ?? null,
+        checksum: selectedRendition?.checksum ?? null,
+        downloadUrl,
+    };
+}
 export const publicFinanceService = {
     async getBookingDocuments(db, bookingId) {
         const [booking] = await db
@@ -136,32 +161,42 @@ export const publicFinanceService = {
         }
         return {
             bookingId,
-            documents: invoiceRows.map((invoice) => {
-                const renditions = renditionByInvoiceId.get(invoice.id) ?? [];
-                const selectedRendition = renditions.find((rendition) => rendition.status === "ready") ?? renditions[0] ?? null;
-                const metadata = getMetadataRecord(selectedRendition?.metadata ?? null);
-                const downloadUrl = getMetadataDownloadUrl(metadata) ?? maybeUrl(selectedRendition?.storageKey ?? null);
-                return {
-                    invoiceId: invoice.id,
-                    invoiceNumber: invoice.invoiceNumber,
-                    invoiceType: invoice.invoiceType,
-                    invoiceStatus: invoice.status,
-                    currency: invoice.currency,
-                    totalCents: invoice.totalCents,
-                    paidCents: invoice.paidCents,
-                    balanceDueCents: invoice.balanceDueCents,
-                    issueDate: invoice.issueDate,
-                    dueDate: invoice.dueDate,
-                    renditionId: selectedRendition?.id ?? null,
-                    documentStatus: selectedRendition?.status ?? "missing",
-                    format: selectedRendition?.format ?? null,
-                    language: selectedRendition?.language ?? null,
-                    generatedAt: normalizeDateTime(selectedRendition?.generatedAt),
-                    fileSize: selectedRendition?.fileSize ?? null,
-                    checksum: selectedRendition?.checksum ?? null,
-                    downloadUrl,
-                };
-            }),
+            documents: invoiceRows.map((invoice) => mapInvoiceDocument(invoice, renditionByInvoiceId.get(invoice.id) ?? [])),
+        };
+    },
+    async getDocumentByReference(db, reference) {
+        const [invoiceMatch, paymentMatch] = await Promise.all([
+            db
+                .select()
+                .from(invoices)
+                .where(eq(invoices.invoiceNumber, reference))
+                .orderBy(desc(invoices.createdAt))
+                .limit(1),
+            db
+                .select({
+                invoiceId: payments.invoiceId,
+            })
+                .from(payments)
+                .where(eq(payments.referenceNumber, reference))
+                .orderBy(desc(payments.createdAt))
+                .limit(1),
+        ]);
+        const invoiceId = invoiceMatch[0]?.id ?? paymentMatch[0]?.invoiceId ?? null;
+        if (!invoiceId) {
+            return null;
+        }
+        const [invoice] = await db.select().from(invoices).where(eq(invoices.id, invoiceId)).limit(1);
+        if (!invoice?.bookingId) {
+            return null;
+        }
+        const renditions = await db
+            .select()
+            .from(invoiceRenditions)
+            .where(eq(invoiceRenditions.invoiceId, invoice.id))
+            .orderBy(desc(invoiceRenditions.createdAt));
+        return {
+            bookingId: invoice.bookingId,
+            ...mapInvoiceDocument(invoice, renditions),
         };
     },
     async getBookingPaymentOptions(db, bookingId, query) {
@@ -254,6 +289,58 @@ export const publicFinanceService = {
                 : null,
         };
     },
+    async getBookingPayments(db, bookingId) {
+        const [booking] = await db
+            .select({ id: bookings.id })
+            .from(bookings)
+            .where(eq(bookings.id, bookingId))
+            .limit(1);
+        if (!booking) {
+            return null;
+        }
+        const invoiceRows = await db
+            .select({
+            id: invoices.id,
+            invoiceNumber: invoices.invoiceNumber,
+            invoiceType: invoices.invoiceType,
+        })
+            .from(invoices)
+            .where(eq(invoices.bookingId, bookingId))
+            .orderBy(desc(invoices.createdAt));
+        if (invoiceRows.length === 0) {
+            return { bookingId, payments: [] };
+        }
+        const invoiceById = new Map(invoiceRows.map((invoice) => [invoice.id, invoice]));
+        const paymentRows = await db
+            .select()
+            .from(payments)
+            .where(or(...invoiceRows.map((invoice) => eq(payments.invoiceId, invoice.id))))
+            .orderBy(desc(payments.paymentDate), desc(payments.createdAt));
+        return {
+            bookingId,
+            payments: paymentRows.flatMap((payment) => {
+                const invoice = invoiceById.get(payment.invoiceId);
+                if (!invoice) {
+                    return [];
+                }
+                return [
+                    {
+                        id: payment.id,
+                        invoiceId: invoice.id,
+                        invoiceNumber: invoice.invoiceNumber,
+                        invoiceType: invoice.invoiceType,
+                        status: payment.status,
+                        paymentMethod: payment.paymentMethod,
+                        amountCents: payment.amountCents,
+                        currency: payment.currency,
+                        paymentDate: payment.paymentDate,
+                        referenceNumber: payment.referenceNumber ?? null,
+                        notes: payment.notes ?? null,
+                    },
+                ];
+            }),
+        };
+    },
     async getPaymentSession(db, sessionId) {
         const session = await financeService.getPaymentSessionById(db, sessionId);
         return session ? toPublicPaymentSession(session) : null;

package/dist/service-settlement.d.ts

@@ -0,0 +1,36 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { Invoice as FinanceInvoice, InvoiceExternalRef } from "./schema.js";
+import type { PolledInvoiceSettlementResult, PollInvoiceSettlementInput } from "./validation.js";
+type SettlementInvoice = FinanceInvoice;
+type SettlementExternalRef = InvoiceExternalRef;
+export interface InvoiceSettlementPollerContext {
+    db: PostgresJsDatabase;
+    invoice: SettlementInvoice;
+    externalRef: SettlementExternalRef;
+    bindings: Record<string, unknown>;
+}
+export interface InvoiceSettlementPollerResult {
+    externalId?: string | null;
+    externalNumber?: string | null;
+    externalUrl?: string | null;
+    status?: string | null;
+    paidAmountCents?: number | null;
+    unpaidAmountCents?: number | null;
+    syncedAt?: string | Date | null;
+    settledAt?: string | Date | null;
+    referenceNumber?: string | null;
+    syncError?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export type InvoiceSettlementPoller = (context: InvoiceSettlementPollerContext) => Promise<InvoiceSettlementPollerResult>;
+export interface FinanceSettlementRuntimeOptions {
+    bindings?: Record<string, unknown>;
+    invoiceSettlementPollers?: Record<string, InvoiceSettlementPoller>;
+}
+export declare const financeSettlementService: {
+    pollInvoiceSettlement(db: PostgresJsDatabase, invoiceId: string, input: PollInvoiceSettlementInput, runtime?: FinanceSettlementRuntimeOptions): Promise<PolledInvoiceSettlementResult | {
+        status: "not_found";
+    }>;
+};
+export {};
+//# sourceMappingURL=service-settlement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-settlement.d.ts","sourceRoot":"","sources":["../src/service-settlement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,KAAK,EAAE,OAAO,IAAI,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAEhF,OAAO,KAAK,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAA;AAEhG,KAAK,iBAAiB,GAAG,cAAc,CAAA;AACvC,KAAK,qBAAqB,GAAG,kBAAkB,CAAA;AAE/C,MAAM,WAAW,8BAA8B;IAC7C,EAAE,EAAE,kBAAkB,CAAA;IACtB,OAAO,EAAE,iBAAiB,CAAA;IAC1B,WAAW,EAAE,qBAAqB,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAClC;AAED,MAAM,WAAW,6BAA6B;IAC5C,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACjC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAA;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CAC1C;AAED,MAAM,MAAM,uBAAuB,GAAG,CACpC,OAAO,EAAE,8BAA8B,KACpC,OAAO,CAAC,6BAA6B,CAAC,CAAA;AAE3C,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAClC,wBAAwB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;CACnE;AAyED,eAAO,MAAM,wBAAwB;8BAE7B,kBAAkB,aACX,MAAM,SACV,0BAA0B,YACxB,+BAA+B,GACvC,OAAO,CAAC,6BAA6B,GAAG;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,CAAC;CAwIpE,CAAA"}

package/dist/service-settlement.js

@@ -0,0 +1,172 @@
+import { financeService } from "./service.js";
+function coerceRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function toIsoString(value) {
+    if (!value)
+        return null;
+    if (value instanceof Date)
+        return value.toISOString();
+    const parsed = new Date(value);
+    return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+}
+function normalizeMoney(value) {
+    if (typeof value !== "number" || Number.isNaN(value))
+        return null;
+    return Math.round(value);
+}
+function resolveReferenceNumber(input, pollResult, externalRef, invoice) {
+    return (input.referenceNumber ??
+        pollResult.referenceNumber ??
+        pollResult.externalNumber ??
+        pollResult.externalId ??
+        externalRef.externalNumber ??
+        externalRef.externalId ??
+        invoice.invoiceNumber);
+}
+function resolvePaymentDate(input, pollResult) {
+    return (input.paymentDate ??
+        toIsoString(pollResult.settledAt) ??
+        toIsoString(pollResult.syncedAt) ??
+        new Date().toISOString());
+}
+async function synchronizeExternalRef(db, invoiceId, externalRef, pollResult) {
+    const syncedAt = toIsoString(pollResult.syncedAt) ?? new Date().toISOString();
+    const row = await financeService.registerInvoiceExternalRef(db, invoiceId, {
+        provider: externalRef.provider,
+        externalId: pollResult.externalId ?? externalRef.externalId ?? null,
+        externalNumber: pollResult.externalNumber ?? externalRef.externalNumber ?? null,
+        externalUrl: pollResult.externalUrl ?? externalRef.externalUrl ?? null,
+        status: pollResult.status ?? externalRef.status ?? null,
+        metadata: pollResult.metadata ?? coerceRecord(externalRef.metadata) ?? null,
+        syncedAt,
+        syncError: pollResult.syncError ?? null,
+    });
+    return {
+        row,
+        syncedAt,
+    };
+}
+export const financeSettlementService = {
+    async pollInvoiceSettlement(db, invoiceId, input, runtime = {}) {
+        let invoice = await financeService.getInvoiceById(db, invoiceId);
+        if (!invoice) {
+            return { status: "not_found" };
+        }
+        const externalRefs = await financeService.listInvoiceExternalRefs(db, invoiceId);
+        const refsToPoll = input.provider
+            ? externalRefs.filter((externalRef) => externalRef.provider === input.provider)
+            : externalRefs;
+        const results = [];
+        for (const externalRef of refsToPoll) {
+            const poller = runtime.invoiceSettlementPollers?.[externalRef.provider];
+            if (!poller) {
+                const synced = await synchronizeExternalRef(db, invoice.id, externalRef, {
+                    syncError: "No settlement poller configured",
+                });
+                results.push({
+                    provider: externalRef.provider,
+                    externalRefId: synced.row?.id ?? externalRef.id,
+                    externalId: synced.row?.externalId ?? externalRef.externalId ?? null,
+                    externalNumber: synced.row?.externalNumber ?? externalRef.externalNumber ?? null,
+                    externalUrl: synced.row?.externalUrl ?? externalRef.externalUrl ?? null,
+                    status: synced.row?.status ?? externalRef.status ?? null,
+                    paidAmountCents: null,
+                    unpaidAmountCents: null,
+                    syncedAt: toIsoString(synced.row?.syncedAt) ?? synced.syncedAt,
+                    settledAt: null,
+                    createdPaymentId: null,
+                    newlyAppliedAmountCents: 0,
+                    syncError: synced.row?.syncError ?? "No settlement poller configured",
+                });
+                continue;
+            }
+            try {
+                const pollResult = await poller({
+                    db,
+                    invoice,
+                    externalRef,
+                    bindings: runtime.bindings ?? {},
+                });
+                const synced = await synchronizeExternalRef(db, invoice.id, externalRef, pollResult);
+                const paidAmountCents = normalizeMoney(pollResult.paidAmountCents);
+                const unpaidAmountCents = normalizeMoney(pollResult.unpaidAmountCents);
+                let newlyAppliedAmountCents = 0;
+                let createdPaymentId = null;
+                if (input.reconcilePayment && paidAmountCents !== null) {
+                    const cappedPaidAmountCents = Math.min(invoice.totalCents, Math.max(0, paidAmountCents));
+                    const outstandingAmountCents = Math.max(0, invoice.totalCents - invoice.paidCents);
+                    newlyAppliedAmountCents = Math.min(outstandingAmountCents, Math.max(0, cappedPaidAmountCents - invoice.paidCents));
+                    if (newlyAppliedAmountCents > 0) {
+                        const payment = await financeService.createPayment(db, invoice.id, {
+                            amountCents: newlyAppliedAmountCents,
+                            currency: invoice.currency,
+                            baseCurrency: invoice.baseCurrency ?? null,
+                            baseAmountCents: invoice.baseCurrency && invoice.baseCurrency === invoice.currency
+                                ? newlyAppliedAmountCents
+                                : null,
+                            fxRateSetId: invoice.fxRateSetId ?? null,
+                            paymentMethod: input.paymentMethod,
+                            paymentInstrumentId: null,
+                            paymentAuthorizationId: null,
+                            paymentCaptureId: null,
+                            status: "completed",
+                            referenceNumber: resolveReferenceNumber(input, pollResult, externalRef, invoice),
+                            paymentDate: resolvePaymentDate(input, pollResult),
+                            notes: input.notes ??
+                                `Settlement reconciled from ${externalRef.provider} external reference`,
+                        });
+                        createdPaymentId = payment?.id ?? null;
+                        invoice = (await financeService.getInvoiceById(db, invoice.id)) ?? invoice;
+                    }
+                }
+                results.push({
+                    provider: externalRef.provider,
+                    externalRefId: synced.row?.id ?? externalRef.id,
+                    externalId: synced.row?.externalId ?? externalRef.externalId ?? null,
+                    externalNumber: synced.row?.externalNumber ?? externalRef.externalNumber ?? null,
+                    externalUrl: synced.row?.externalUrl ?? externalRef.externalUrl ?? null,
+                    status: synced.row?.status ?? externalRef.status ?? null,
+                    paidAmountCents,
+                    unpaidAmountCents,
+                    syncedAt: toIsoString(synced.row?.syncedAt) ?? synced.syncedAt,
+                    settledAt: toIsoString(pollResult.settledAt),
+                    createdPaymentId,
+                    newlyAppliedAmountCents,
+                    syncError: synced.row?.syncError ?? pollResult.syncError ?? null,
+                });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : "Settlement polling failed";
+                const synced = await synchronizeExternalRef(db, invoice.id, externalRef, {
+                    syncError: message,
+                });
+                results.push({
+                    provider: externalRef.provider,
+                    externalRefId: synced.row?.id ?? externalRef.id,
+                    externalId: synced.row?.externalId ?? externalRef.externalId ?? null,
+                    externalNumber: synced.row?.externalNumber ?? externalRef.externalNumber ?? null,
+                    externalUrl: synced.row?.externalUrl ?? externalRef.externalUrl ?? null,
+                    status: synced.row?.status ?? externalRef.status ?? null,
+                    paidAmountCents: null,
+                    unpaidAmountCents: null,
+                    syncedAt: toIsoString(synced.row?.syncedAt) ?? synced.syncedAt,
+                    settledAt: null,
+                    createdPaymentId: null,
+                    newlyAppliedAmountCents: 0,
+                    syncError: synced.row?.syncError ?? message,
+                });
+            }
+        }
+        invoice = (await financeService.getInvoiceById(db, invoice.id)) ?? invoice;
+        return {
+            invoiceId: invoice.id,
+            invoiceStatus: invoice.status,
+            paidCents: invoice.paidCents,
+            balanceDueCents: invoice.balanceDueCents,
+            results,
+        };
+    },
+};