@voyant-travel/finance 0.119.5

package/dist/service-payment-authorizations.d.ts

@@ -0,0 +1,164 @@
+import type { CreatePaymentAuthorizationInput, CreatePaymentCaptureInput, FinanceServiceRuntime, PaymentAuthorizationListQuery, PaymentCaptureListQuery, PostgresJsDatabase, UpdatePaymentAuthorizationInput, UpdatePaymentCaptureInput } from "./service-shared.js";
+export declare const financePaymentAuthorizationService: {
+    listPaymentAuthorizations(db: PostgresJsDatabase, query: PaymentAuthorizationListQuery): Promise<{
+        data: {
+            id: string;
+            bookingId: string | null;
+            orderId: string | null;
+            invoiceId: string | null;
+            bookingGuaranteeId: string | null;
+            paymentInstrumentId: string | null;
+            status: "failed" | "pending" | "expired" | "authorized" | "partially_captured" | "captured" | "voided";
+            captureMode: "manual" | "automatic";
+            currency: string;
+            amountCents: number;
+            provider: string | null;
+            externalAuthorizationId: string | null;
+            approvalCode: string | null;
+            authorizedAt: Date | null;
+            expiresAt: Date | null;
+            voidedAt: Date | null;
+            notes: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getPaymentAuthorizationById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        bookingId: string | null;
+        orderId: string | null;
+        invoiceId: string | null;
+        bookingGuaranteeId: string | null;
+        paymentInstrumentId: string | null;
+        status: "failed" | "pending" | "expired" | "authorized" | "partially_captured" | "captured" | "voided";
+        captureMode: "manual" | "automatic";
+        currency: string;
+        amountCents: number;
+        provider: string | null;
+        externalAuthorizationId: string | null;
+        approvalCode: string | null;
+        authorizedAt: Date | null;
+        expiresAt: Date | null;
+        voidedAt: Date | null;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createPaymentAuthorization(db: PostgresJsDatabase, data: CreatePaymentAuthorizationInput, runtime?: FinanceServiceRuntime): Promise<{
+        currency: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        status: "failed" | "pending" | "expired" | "authorized" | "partially_captured" | "captured" | "voided";
+        bookingId: string | null;
+        provider: string | null;
+        invoiceId: string | null;
+        amountCents: number;
+        notes: string | null;
+        bookingGuaranteeId: string | null;
+        expiresAt: Date | null;
+        voidedAt: Date | null;
+        orderId: string | null;
+        paymentInstrumentId: string | null;
+        captureMode: "manual" | "automatic";
+        externalAuthorizationId: string | null;
+        approvalCode: string | null;
+        authorizedAt: Date | null;
+    } | null>;
+    updatePaymentAuthorization(db: PostgresJsDatabase, id: string, data: UpdatePaymentAuthorizationInput, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+        bookingId: string | null;
+        orderId: string | null;
+        invoiceId: string | null;
+        bookingGuaranteeId: string | null;
+        paymentInstrumentId: string | null;
+        status: "failed" | "pending" | "expired" | "authorized" | "partially_captured" | "captured" | "voided";
+        captureMode: "manual" | "automatic";
+        currency: string;
+        amountCents: number;
+        provider: string | null;
+        externalAuthorizationId: string | null;
+        approvalCode: string | null;
+        authorizedAt: Date | null;
+        expiresAt: Date | null;
+        voidedAt: Date | null;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deletePaymentAuthorization(db: PostgresJsDatabase, id: string, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+    } | null>;
+    listPaymentCaptures(db: PostgresJsDatabase, query: PaymentCaptureListQuery): Promise<{
+        data: {
+            id: string;
+            paymentAuthorizationId: string | null;
+            invoiceId: string | null;
+            status: "failed" | "pending" | "voided" | "completed" | "refunded";
+            currency: string;
+            amountCents: number;
+            provider: string | null;
+            externalCaptureId: string | null;
+            capturedAt: Date | null;
+            settledAt: Date | null;
+            notes: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getPaymentCaptureById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        paymentAuthorizationId: string | null;
+        invoiceId: string | null;
+        status: "failed" | "pending" | "voided" | "completed" | "refunded";
+        currency: string;
+        amountCents: number;
+        provider: string | null;
+        externalCaptureId: string | null;
+        capturedAt: Date | null;
+        settledAt: Date | null;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createPaymentCapture(db: PostgresJsDatabase, data: CreatePaymentCaptureInput, runtime?: FinanceServiceRuntime): Promise<{
+        currency: string;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        status: "failed" | "pending" | "voided" | "completed" | "refunded";
+        provider: string | null;
+        invoiceId: string | null;
+        amountCents: number;
+        notes: string | null;
+        paymentAuthorizationId: string | null;
+        externalCaptureId: string | null;
+        capturedAt: Date | null;
+        settledAt: Date | null;
+    } | null>;
+    updatePaymentCapture(db: PostgresJsDatabase, id: string, data: UpdatePaymentCaptureInput, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+        paymentAuthorizationId: string | null;
+        invoiceId: string | null;
+        status: "failed" | "pending" | "voided" | "completed" | "refunded";
+        currency: string;
+        amountCents: number;
+        provider: string | null;
+        externalCaptureId: string | null;
+        capturedAt: Date | null;
+        settledAt: Date | null;
+        notes: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deletePaymentCapture(db: PostgresJsDatabase, id: string, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=service-payment-authorizations.d.ts.map

package/dist/service-payment-authorizations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-payment-authorizations.d.ts","sourceRoot":"","sources":["../src/service-payment-authorizations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,+BAA+B,EAC/B,yBAAyB,EACzB,qBAAqB,EACrB,6BAA6B,EAC7B,uBAAuB,EACvB,kBAAkB,EAClB,+BAA+B,EAC/B,yBAAyB,EAC1B,MAAM,qBAAqB,CAAA;AA8C5B,eAAO,MAAM,kCAAkC;kCACT,kBAAkB,SAAS,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;oCAyBtD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;mCAU9D,kBAAkB,QAChB,+BAA+B,YAC5B,qBAAqB;;;;;;;;;;;;;;;;;;;;;mCAkD1B,kBAAkB,MAClB,MAAM,QACJ,+BAA+B,YAC5B,qBAAqB;;;;;;;;;;;;;;;;;;;;;mCAuD1B,kBAAkB,MAClB,MAAM,YACD,qBAAqB;;;4BAoCF,kBAAkB,SAAS,uBAAuB;;;;;;;;;;;;;;;;;;;;8BAqBhD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;6BAMxD,kBAAkB,QAChB,yBAAyB,YACtB,qBAAqB;;;;;;;;;;;;;;;6BAuC1B,kBAAkB,MAClB,MAAM,QACJ,yBAAyB,YACtB,qBAAqB;;;;;;;;;;;;;;;6BAyC1B,kBAAkB,MAClB,MAAM,YACD,qBAAqB;;;CAmCjC,CAAA"}

package/dist/service-payment-authorizations.js

@@ -0,0 +1,227 @@
+import { and, appendActionLedgerMutation, buildPaymentAuthorizationCreateActionLedgerInput, buildPaymentAuthorizationDeleteActionLedgerInput, buildPaymentAuthorizationUpdateActionLedgerInput, buildPaymentCaptureCreateActionLedgerInput, buildPaymentCaptureDeleteActionLedgerInput, buildPaymentCaptureUpdateActionLedgerInput, desc, eq, paginate, paymentAuthorizations, paymentCaptures, sql, toTimestamp, } from "./service-shared.js";
+function derivePaymentAuthorizationTargetColumns(data) {
+    const explicitTarget = "target" in data ? data.target : undefined;
+    if (!explicitTarget)
+        return {};
+    switch (explicitTarget.type) {
+        case "booking":
+            return { bookingId: explicitTarget.bookingId };
+        case "invoice":
+            return { invoiceId: explicitTarget.invoiceId };
+        case "booking_guarantee":
+            return { bookingGuaranteeId: explicitTarget.bookingGuaranteeId };
+        case "legacy_order":
+            return { orderId: explicitTarget.legacyOrderId };
+        default:
+            return {};
+    }
+}
+export const financePaymentAuthorizationService = {
+    async listPaymentAuthorizations(db, query) {
+        const conditions = [];
+        if (query.bookingId)
+            conditions.push(eq(paymentAuthorizations.bookingId, query.bookingId));
+        if (query.legacyOrderId)
+            conditions.push(eq(paymentAuthorizations.orderId, query.legacyOrderId));
+        if (query.invoiceId)
+            conditions.push(eq(paymentAuthorizations.invoiceId, query.invoiceId));
+        if (query.bookingGuaranteeId)
+            conditions.push(eq(paymentAuthorizations.bookingGuaranteeId, query.bookingGuaranteeId));
+        if (query.paymentInstrumentId)
+            conditions.push(eq(paymentAuthorizations.paymentInstrumentId, query.paymentInstrumentId));
+        if (query.status)
+            conditions.push(eq(paymentAuthorizations.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(paymentAuthorizations)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(paymentAuthorizations.createdAt)), db.select({ total: sql `count(*)::int` }).from(paymentAuthorizations).where(where), query.limit, query.offset);
+    },
+    async getPaymentAuthorizationById(db, id) {
+        const [row] = await db
+            .select()
+            .from(paymentAuthorizations)
+            .where(eq(paymentAuthorizations.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createPaymentAuthorization(db, data, runtime = {}) {
+        const targetColumns = derivePaymentAuthorizationTargetColumns(data);
+        const { legacyOrderId, target: _explicitTarget, provenance: _provenance, ...authorizationData } = data;
+        const resolvedLegacyOrderId = legacyOrderId ?? null;
+        const createAuthorization = (writer) => writer
+            .insert(paymentAuthorizations)
+            .values({
+            ...authorizationData,
+            ...targetColumns,
+            orderId: targetColumns.orderId ?? resolvedLegacyOrderId,
+            authorizedAt: toTimestamp(data.authorizedAt),
+            expiresAt: toTimestamp(data.expiresAt),
+            voidedAt: toTimestamp(data.voidedAt),
+        })
+            .returning();
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            const [row] = await db.transaction(async (tx) => {
+                const created = await createAuthorization(tx);
+                if (created[0]) {
+                    await appendActionLedgerMutation(tx, await buildPaymentAuthorizationCreateActionLedgerInput(actionLedgerContext, { authorization: created[0] }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                }
+                return created;
+            });
+            return row ?? null;
+        }
+        const [row] = await createAuthorization(db);
+        return row ?? null;
+    },
+    async updatePaymentAuthorization(db, id, data, runtime = {}) {
+        const targetColumns = derivePaymentAuthorizationTargetColumns(data);
+        const { legacyOrderId, target: _explicitTarget, provenance: _provenance, ...authorizationData } = data;
+        const resolvedLegacyOrderId = legacyOrderId;
+        const updateAuthorization = (writer) => writer
+            .update(paymentAuthorizations)
+            .set({
+            ...authorizationData,
+            ...targetColumns,
+            orderId: targetColumns.orderId ??
+                (resolvedLegacyOrderId === undefined ? undefined : (resolvedLegacyOrderId ?? null)),
+            authorizedAt: data.authorizedAt === undefined ? undefined : toTimestamp(data.authorizedAt),
+            expiresAt: data.expiresAt === undefined ? undefined : toTimestamp(data.expiresAt),
+            voidedAt: data.voidedAt === undefined ? undefined : toTimestamp(data.voidedAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(paymentAuthorizations.id, id))
+            .returning();
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            const [row] = await db.transaction(async (tx) => {
+                const updated = await updateAuthorization(tx);
+                if (updated[0]) {
+                    await appendActionLedgerMutation(tx, buildPaymentAuthorizationUpdateActionLedgerInput(actionLedgerContext, { authorization: updated[0], changes: data }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                }
+                return updated;
+            });
+            return row ?? null;
+        }
+        const [row] = await updateAuthorization(db);
+        return row ?? null;
+    },
+    async deletePaymentAuthorization(db, id, runtime = {}) {
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            return db.transaction(async (tx) => {
+                const [existing] = await tx
+                    .select()
+                    .from(paymentAuthorizations)
+                    .where(eq(paymentAuthorizations.id, id))
+                    .limit(1);
+                if (!existing) {
+                    return null;
+                }
+                await tx.delete(paymentAuthorizations).where(eq(paymentAuthorizations.id, id));
+                await appendActionLedgerMutation(tx, buildPaymentAuthorizationDeleteActionLedgerInput(actionLedgerContext, { authorization: existing }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                return { id: existing.id };
+            });
+        }
+        const [row] = await db
+            .delete(paymentAuthorizations)
+            .where(eq(paymentAuthorizations.id, id))
+            .returning({ id: paymentAuthorizations.id });
+        return row ?? null;
+    },
+    async listPaymentCaptures(db, query) {
+        const conditions = [];
+        if (query.paymentAuthorizationId)
+            conditions.push(eq(paymentCaptures.paymentAuthorizationId, query.paymentAuthorizationId));
+        if (query.invoiceId)
+            conditions.push(eq(paymentCaptures.invoiceId, query.invoiceId));
+        if (query.status)
+            conditions.push(eq(paymentCaptures.status, query.status));
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(paymentCaptures)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(paymentCaptures.createdAt)), db.select({ total: sql `count(*)::int` }).from(paymentCaptures).where(where), query.limit, query.offset);
+    },
+    async getPaymentCaptureById(db, id) {
+        const [row] = await db.select().from(paymentCaptures).where(eq(paymentCaptures.id, id)).limit(1);
+        return row ?? null;
+    },
+    async createPaymentCapture(db, data, runtime = {}) {
+        const createCapture = (writer) => writer
+            .insert(paymentCaptures)
+            .values({
+            ...data,
+            capturedAt: toTimestamp(data.capturedAt),
+            settledAt: toTimestamp(data.settledAt),
+        })
+            .returning();
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            const [row] = await db.transaction(async (tx) => {
+                const created = await createCapture(tx);
+                if (created[0]) {
+                    await appendActionLedgerMutation(tx, await buildPaymentCaptureCreateActionLedgerInput(actionLedgerContext, { capture: created[0] }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                }
+                return created;
+            });
+            return row ?? null;
+        }
+        const [row] = await createCapture(db);
+        return row ?? null;
+    },
+    async updatePaymentCapture(db, id, data, runtime = {}) {
+        const updateCapture = (writer) => writer
+            .update(paymentCaptures)
+            .set({
+            ...data,
+            capturedAt: data.capturedAt === undefined ? undefined : toTimestamp(data.capturedAt),
+            settledAt: data.settledAt === undefined ? undefined : toTimestamp(data.settledAt),
+            updatedAt: new Date(),
+        })
+            .where(eq(paymentCaptures.id, id))
+            .returning();
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            const [row] = await db.transaction(async (tx) => {
+                const updated = await updateCapture(tx);
+                if (updated[0]) {
+                    await appendActionLedgerMutation(tx, buildPaymentCaptureUpdateActionLedgerInput(actionLedgerContext, { capture: updated[0], changes: data }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                }
+                return updated;
+            });
+            return row ?? null;
+        }
+        const [row] = await updateCapture(db);
+        return row ?? null;
+    },
+    async deletePaymentCapture(db, id, runtime = {}) {
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            return db.transaction(async (tx) => {
+                const [existing] = await tx
+                    .select()
+                    .from(paymentCaptures)
+                    .where(eq(paymentCaptures.id, id))
+                    .limit(1);
+                if (!existing) {
+                    return null;
+                }
+                await tx.delete(paymentCaptures).where(eq(paymentCaptures.id, id));
+                await appendActionLedgerMutation(tx, buildPaymentCaptureDeleteActionLedgerInput(actionLedgerContext, { capture: existing }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                return { id: existing.id };
+            });
+        }
+        const [row] = await db
+            .delete(paymentCaptures)
+            .where(eq(paymentCaptures.id, id))
+            .returning({ id: paymentCaptures.id });
+        return row ?? null;
+    },
+};

package/dist/service-payment-instruments.d.ts

@@ -0,0 +1,116 @@
+import type { CreatePaymentInstrumentInput, FinanceServiceRuntime, PaymentInstrumentListQuery, PostgresJsDatabase, UpdatePaymentInstrumentInput } from "./service-shared.js";
+export declare const financePaymentInstrumentService: {
+    listPaymentInstruments(db: PostgresJsDatabase, query: PaymentInstrumentListQuery): Promise<{
+        data: {
+            id: string;
+            ownerType: "other" | "channel" | "client" | "supplier" | "agency" | "internal";
+            personId: string | null;
+            organizationId: string | null;
+            supplierId: string | null;
+            channelId: string | null;
+            instrumentType: "other" | "credit_card" | "voucher" | "debit_card" | "cash" | "wallet" | "direct_bill" | "bank_account";
+            status: "active" | "expired" | "inactive" | "revoked" | "failed_verification";
+            label: string;
+            provider: string | null;
+            brand: string | null;
+            last4: string | null;
+            holderName: string | null;
+            expiryMonth: number | null;
+            expiryYear: number | null;
+            externalToken: string | null;
+            externalCustomerId: string | null;
+            billingEmail: string | null;
+            billingAddress: string | null;
+            directBillReference: string | null;
+            notes: string | null;
+            metadata: unknown;
+            createdAt: Date;
+            updatedAt: Date;
+        }[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+    getPaymentInstrumentById(db: PostgresJsDatabase, id: string): Promise<{
+        id: string;
+        ownerType: "other" | "channel" | "client" | "supplier" | "agency" | "internal";
+        personId: string | null;
+        organizationId: string | null;
+        supplierId: string | null;
+        channelId: string | null;
+        instrumentType: "other" | "credit_card" | "voucher" | "debit_card" | "cash" | "wallet" | "direct_bill" | "bank_account";
+        status: "active" | "expired" | "inactive" | "revoked" | "failed_verification";
+        label: string;
+        provider: string | null;
+        brand: string | null;
+        last4: string | null;
+        holderName: string | null;
+        expiryMonth: number | null;
+        expiryYear: number | null;
+        externalToken: string | null;
+        externalCustomerId: string | null;
+        billingEmail: string | null;
+        billingAddress: string | null;
+        directBillReference: string | null;
+        notes: string | null;
+        metadata: unknown;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createPaymentInstrument(db: PostgresJsDatabase, data: CreatePaymentInstrumentInput, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+        brand: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        metadata: unknown;
+        label: string;
+        status: "active" | "expired" | "inactive" | "revoked" | "failed_verification";
+        provider: string | null;
+        notes: string | null;
+        personId: string | null;
+        organizationId: string | null;
+        ownerType: "other" | "channel" | "client" | "supplier" | "agency" | "internal";
+        supplierId: string | null;
+        channelId: string | null;
+        instrumentType: "other" | "credit_card" | "voucher" | "debit_card" | "cash" | "wallet" | "direct_bill" | "bank_account";
+        last4: string | null;
+        holderName: string | null;
+        expiryMonth: number | null;
+        expiryYear: number | null;
+        externalToken: string | null;
+        externalCustomerId: string | null;
+        billingEmail: string | null;
+        billingAddress: string | null;
+        directBillReference: string | null;
+    } | null>;
+    updatePaymentInstrument(db: PostgresJsDatabase, id: string, data: UpdatePaymentInstrumentInput, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+        ownerType: "other" | "channel" | "client" | "supplier" | "agency" | "internal";
+        personId: string | null;
+        organizationId: string | null;
+        supplierId: string | null;
+        channelId: string | null;
+        instrumentType: "other" | "credit_card" | "voucher" | "debit_card" | "cash" | "wallet" | "direct_bill" | "bank_account";
+        status: "active" | "expired" | "inactive" | "revoked" | "failed_verification";
+        label: string;
+        provider: string | null;
+        brand: string | null;
+        last4: string | null;
+        holderName: string | null;
+        expiryMonth: number | null;
+        expiryYear: number | null;
+        externalToken: string | null;
+        externalCustomerId: string | null;
+        billingEmail: string | null;
+        billingAddress: string | null;
+        directBillReference: string | null;
+        notes: string | null;
+        metadata: unknown;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    deletePaymentInstrument(db: PostgresJsDatabase, id: string, runtime?: FinanceServiceRuntime): Promise<{
+        id: string;
+    } | null>;
+};
+//# sourceMappingURL=service-payment-instruments.d.ts.map

package/dist/service-payment-instruments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-payment-instruments.d.ts","sourceRoot":"","sources":["../src/service-payment-instruments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,qBAAqB,EACrB,0BAA0B,EAC1B,kBAAkB,EAClB,4BAA4B,EAC7B,MAAM,qBAAqB,CAAA;AAgB5B,eAAO,MAAM,+BAA+B;+BACT,kBAAkB,SAAS,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAgCnD,kBAAkB,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;gCAU3D,kBAAkB,QAChB,4BAA4B,YACzB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;gCAgC1B,kBAAkB,MAClB,MAAM,QACJ,4BAA4B,YACzB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;gCAoC1B,kBAAkB,MAClB,MAAM,YACD,qBAAqB;;;CAmCjC,CAAA"}

package/dist/service-payment-instruments.js

@@ -0,0 +1,99 @@
+import { and, appendActionLedgerMutation, buildPaymentInstrumentCreateActionLedgerInput, buildPaymentInstrumentDeleteActionLedgerInput, buildPaymentInstrumentUpdateActionLedgerInput, desc, eq, ilike, or, paginate, paymentInstruments, sql, } from "./service-shared.js";
+export const financePaymentInstrumentService = {
+    async listPaymentInstruments(db, query) {
+        const conditions = [];
+        if (query.ownerType)
+            conditions.push(eq(paymentInstruments.ownerType, query.ownerType));
+        if (query.personId)
+            conditions.push(eq(paymentInstruments.personId, query.personId));
+        if (query.organizationId)
+            conditions.push(eq(paymentInstruments.organizationId, query.organizationId));
+        if (query.supplierId)
+            conditions.push(eq(paymentInstruments.supplierId, query.supplierId));
+        if (query.channelId)
+            conditions.push(eq(paymentInstruments.channelId, query.channelId));
+        if (query.status)
+            conditions.push(eq(paymentInstruments.status, query.status));
+        if (query.instrumentType)
+            conditions.push(eq(paymentInstruments.instrumentType, query.instrumentType));
+        if (query.search) {
+            const term = `%${query.search}%`;
+            conditions.push(or(ilike(paymentInstruments.label, term), ilike(paymentInstruments.provider, term)));
+        }
+        const where = conditions.length ? and(...conditions) : undefined;
+        return paginate(db
+            .select()
+            .from(paymentInstruments)
+            .where(where)
+            .limit(query.limit)
+            .offset(query.offset)
+            .orderBy(desc(paymentInstruments.updatedAt)), db.select({ total: sql `count(*)::int` }).from(paymentInstruments).where(where), query.limit, query.offset);
+    },
+    async getPaymentInstrumentById(db, id) {
+        const [row] = await db
+            .select()
+            .from(paymentInstruments)
+            .where(eq(paymentInstruments.id, id))
+            .limit(1);
+        return row ?? null;
+    },
+    async createPaymentInstrument(db, data, runtime = {}) {
+        const createInstrument = (writer) => writer.insert(paymentInstruments).values(data).returning();
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            const [row] = await db.transaction(async (tx) => {
+                const created = await createInstrument(tx);
+                if (created[0]) {
+                    await appendActionLedgerMutation(tx, buildPaymentInstrumentCreateActionLedgerInput(actionLedgerContext, { instrument: created[0] }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                }
+                return created;
+            });
+            return row ?? null;
+        }
+        const [row] = await createInstrument(db);
+        return row ?? null;
+    },
+    async updatePaymentInstrument(db, id, data, runtime = {}) {
+        const updateInstrument = (writer) => writer
+            .update(paymentInstruments)
+            .set({ ...data, updatedAt: new Date() })
+            .where(eq(paymentInstruments.id, id))
+            .returning();
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            const [row] = await db.transaction(async (tx) => {
+                const updated = await updateInstrument(tx);
+                if (updated[0]) {
+                    await appendActionLedgerMutation(tx, buildPaymentInstrumentUpdateActionLedgerInput(actionLedgerContext, { instrument: updated[0], changes: data }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                }
+                return updated;
+            });
+            return row ?? null;
+        }
+        const [row] = await updateInstrument(db);
+        return row ?? null;
+    },
+    async deletePaymentInstrument(db, id, runtime = {}) {
+        const actionLedgerContext = runtime.actionLedgerContext;
+        if (actionLedgerContext) {
+            return db.transaction(async (tx) => {
+                const [existing] = await tx
+                    .select()
+                    .from(paymentInstruments)
+                    .where(eq(paymentInstruments.id, id))
+                    .limit(1);
+                if (!existing) {
+                    return null;
+                }
+                await tx.delete(paymentInstruments).where(eq(paymentInstruments.id, id));
+                await appendActionLedgerMutation(tx, buildPaymentInstrumentDeleteActionLedgerInput(actionLedgerContext, { instrument: existing }, { authorizationSource: runtime.actionLedgerAuthorizationSource }));
+                return { id: existing.id };
+            });
+        }
+        const [row] = await db
+            .delete(paymentInstruments)
+            .where(eq(paymentInstruments.id, id))
+            .returning({ id: paymentInstruments.id });
+        return row ?? null;
+    },
+};