@voyantjs/plugin-netopia 0.24.1 → 0.24.3

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAEhE,OAAO,EAAoB,KAAK,UAAU,EAAiB,MAAM,gBAAgB,CAAA;AACjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAKjE,OAAO,KAAK,EAAE,qBAAqB,EAAiC,MAAM,YAAY,CAAA;AAStF,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,EAAE;QACT,SAAS,EAAE,eAAe,CAAA;QAC1B,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,6BAA6B,8BAA8B,CAAA;AAkBxE,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,qBAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAgK7E;AAOD,wBAAgB,6BAA6B,CAAC,OAAO,GAAE,qBAA0B,GAAG,aAAa,CAKhG;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU,CAoBjF;AAED,oDAAoD;AACpD,eAAO,MAAM,iBAAiB,0BAAoB,CAAA;AAElD,eAAO,MAAM,uBAAuB,eAAkC,CAAA"}

package/dist/plugin.js

@@ -0,0 +1,168 @@
+import { FINANCE_ROUTE_RUNTIME_CONTAINER_KEY } from "@voyantjs/finance";
+import { defineHonoBundle, parseJsonBody } from "@voyantjs/hono";
+import { Hono } from "hono";
+import { resolveNetopiaRuntimeOptions } from "./client.js";
+import { netopiaService } from "./service.js";
+import { netopiaCollectBookingGuaranteeSchema, netopiaCollectBookingScheduleSchema, netopiaCollectInvoiceSchema, netopiaStartPaymentSessionSchema, netopiaWebhookPayloadSchema, } from "./validation.js";
+export const NETOPIA_RUNTIME_CONTAINER_KEY = "providers.netopia.runtime";
+function getNetopiaRuntime(bindings, options, resolveFromContainer) {
+    if (resolveFromContainer) {
+        try {
+            return resolveFromContainer(NETOPIA_RUNTIME_CONTAINER_KEY);
+        }
+        catch {
+            // Fall through to per-request resolution when bootstrap has not run.
+        }
+    }
+    return resolveNetopiaRuntimeOptions(bindings, options);
+}
+export function createNetopiaFinanceRoutes(options = {}) {
+    const handleNetopiaError = (message) => {
+        if (message.includes("not found") ||
+            message.includes("Payment schedule not found") ||
+            message.includes("Booking guarantee not found") ||
+            message.includes("Invoice not found")) {
+            return { status: 404, message };
+        }
+        if (message.includes("not startable") || message.includes("already assigned")) {
+            return { status: 409, message };
+        }
+        if (message.includes("Cannot create payment session") ||
+            message.includes("outstanding balance") ||
+            message.includes("No recipient available")) {
+            return { status: 409, message };
+        }
+        if (message.includes("Missing Netopia config")) {
+            return { status: 500, message };
+        }
+        return { status: 502, message };
+    };
+    const resolveRuntime = (c) => getNetopiaRuntime(c.env, options, (key) => c.var.container.resolve(key));
+    return new Hono()
+        .post("/providers/netopia/payment-sessions/:sessionId/start", async (c) => {
+        try {
+            const data = await parseJsonBody(c, netopiaStartPaymentSessionSchema);
+            const runtime = resolveRuntime(c);
+            const result = await netopiaService.startPaymentSession(c.get("db"), c.req.param("sessionId"), data, runtime, undefined);
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to start Netopia payment";
+            if (message.includes("Payment session not found")) {
+                return c.json({ error: message }, 404);
+            }
+            if (message.includes("not startable") || message.includes("already assigned")) {
+                return c.json({ error: message }, 409);
+            }
+            if (message.includes("Missing Netopia config")) {
+                return c.json({ error: message }, 500);
+            }
+            return c.json({ error: message }, 502);
+        }
+    })
+        .post("/providers/netopia/bookings/:bookingId/payment-schedules/:scheduleId/collect", async (c) => {
+        try {
+            const data = await parseJsonBody(c, netopiaCollectBookingScheduleSchema);
+            const runtime = resolveRuntime(c);
+            const result = await netopiaService.collectBookingSchedule(c.get("db"), c.req.param("scheduleId"), data, runtime, undefined, undefined, c.env);
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to collect schedule payment";
+            const response = handleNetopiaError(message);
+            return c.json({ error: response.message }, response.status);
+        }
+    })
+        .post("/providers/netopia/bookings/:bookingId/guarantees/:guaranteeId/collect", async (c) => {
+        try {
+            const data = await parseJsonBody(c, netopiaCollectBookingGuaranteeSchema);
+            const runtime = resolveRuntime(c);
+            const result = await netopiaService.collectBookingGuarantee(c.get("db"), c.req.param("guaranteeId"), data, runtime, undefined, undefined, c.env);
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to collect guarantee payment";
+            const response = handleNetopiaError(message);
+            return c.json({ error: response.message }, response.status);
+        }
+    })
+        .post("/providers/netopia/invoices/:invoiceId/collect", async (c) => {
+        try {
+            const data = await parseJsonBody(c, netopiaCollectInvoiceSchema);
+            const runtime = resolveRuntime(c);
+            const result = await netopiaService.collectInvoice(c.get("db"), c.req.param("invoiceId"), data, runtime, undefined, undefined, c.env);
+            return c.json({ data: result }, 201);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Failed to collect invoice payment";
+            const response = handleNetopiaError(message);
+            return c.json({ error: response.message }, response.status);
+        }
+    })
+        .post("/providers/netopia/callback", async (c) => {
+        const payload = await parseJsonBody(c, netopiaWebhookPayloadSchema);
+        const runtime = resolveRuntime(c);
+        const financeRuntime = (() => {
+            try {
+                return c.var.container?.resolve(FINANCE_ROUTE_RUNTIME_CONTAINER_KEY);
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const result = await netopiaService.handleCallback(c.get("db"), payload, runtime, c.env, financeRuntime ? { eventBus: financeRuntime.eventBus } : undefined);
+        return c.json({ data: result });
+    })
+        .get("/providers/netopia/config", async (c) => {
+        try {
+            const runtime = resolveRuntime(c);
+            return c.json({
+                data: {
+                    apiUrl: runtime.apiUrl,
+                    notifyUrl: runtime.notifyUrl,
+                    redirectUrl: runtime.redirectUrl,
+                    emailTemplate: runtime.emailTemplate,
+                    language: runtime.language,
+                    successStatuses: runtime.successStatuses,
+                    processingStatuses: runtime.processingStatuses,
+                },
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Missing Netopia config";
+            return c.json({ error: message }, 500);
+        }
+    });
+}
+const netopiaFinanceExtensionDef = {
+    name: "netopia-finance",
+    module: "finance",
+};
+export function createNetopiaFinanceExtension(options = {}) {
+    return {
+        extension: netopiaFinanceExtensionDef,
+        routes: createNetopiaFinanceRoutes(options),
+    };
+}
+export function netopiaHonoBundle(options = {}) {
+    return defineHonoBundle({
+        name: "netopia",
+        version: "0.1.0",
+        bootstrap: ({ bindings, container }) => {
+            try {
+                container.register(NETOPIA_RUNTIME_CONTAINER_KEY, resolveNetopiaRuntimeOptions(bindings, options));
+            }
+            catch (error) {
+                // Defer resolution to per-request handlers. Missing env should only fail
+                // Netopia-owned routes, not the whole app — `getNetopiaRuntime` will retry
+                // from bindings on each request and surface the same error on Netopia calls.
+                const message = error instanceof Error ? error.message : String(error);
+                console.warn(`[netopia] Runtime bootstrap skipped: ${message}`);
+            }
+        },
+        extensions: [createNetopiaFinanceExtension(options)],
+    });
+}
+/** @deprecated Prefer {@link netopiaHonoBundle}. */
+export const netopiaHonoPlugin = netopiaHonoBundle;
+export const netopiaFinanceExtension = createNetopiaFinanceExtension();

package/dist/service-callback.d.ts

@@ -0,0 +1,8 @@
+import type { EventBus } from "@voyantjs/core";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type NetopiaCallbackResult } from "./service-shared.js";
+import type { NetopiaRuntimeOptions, NetopiaWebhookPayload } from "./types.js";
+export declare function handleCallback(db: PostgresJsDatabase, payload: NetopiaWebhookPayload, runtimeOptions?: NetopiaRuntimeOptions, bindings?: Record<string, unknown>, financeRuntime?: {
+    eventBus?: EventBus;
+}): Promise<NetopiaCallbackResult>;
+//# sourceMappingURL=service-callback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-callback.d.ts","sourceRoot":"","sources":["../src/service-callback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAE9E,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,EACtB,OAAO,EAAE,qBAAqB,EAC9B,cAAc,GAAE,qBAA0B,EAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,cAAc,GAAE;IAAE,QAAQ,CAAC,EAAE,QAAQ,CAAA;CAAO,GAC3C,OAAO,CAAC,qBAAqB,CAAC,CAqIhC"}

package/dist/service-callback.js

@@ -0,0 +1,113 @@
+import { resolveNetopiaRuntimeOptions } from "./client.js";
+import { financeService, mapNetopiaPaymentStatus, mergeRecord, } from "./service-shared.js";
+export async function handleCallback(db, payload, runtimeOptions = {}, bindings, financeRuntime = {}) {
+    const runtime = resolveNetopiaRuntimeOptions(bindings, runtimeOptions);
+    const orderId = payload.order.orderID;
+    const lookup = await financeService.listPaymentSessions(db, {
+        provider: "netopia",
+        externalReference: orderId,
+        limit: 1,
+        offset: 0,
+    });
+    let session = lookup.data[0] ?? null;
+    if (!session) {
+        session = await financeService.getPaymentSessionById(db, orderId);
+    }
+    if (!session) {
+        return {
+            action: "ignored",
+            reason: "payment_session_not_found",
+            session: null,
+            orderId,
+        };
+    }
+    const callbackState = mapNetopiaPaymentStatus(payload.payment.status, runtime);
+    const providerPayload = mergeRecord(session.providerPayload, {
+        netopiaCallback: payload,
+    });
+    // Note: we intentionally don't validate `payment.amount` / `payment.currency`
+    // against the session. Netopia auto-converts non-RON orders into RON for
+    // processing (so an EUR session always callbacks with `currency: "RON"` and
+    // a converted amount). Any strict equality check here would reject every
+    // legitimate cross-currency payment. The trustworthy field is
+    // `payment.status` — the orderID is the unguessable secret that ties the
+    // callback to the session, and Netopia is the only party that knows it.
+    // For tamper detection beyond that, wrap this handler at the route layer
+    // and verify the processed amount via your own FX source.
+    if (callbackState === "processing") {
+        const updated = await financeService.updatePaymentSession(db, session.id, {
+            status: "processing",
+            provider: "netopia",
+            providerSessionId: payload.payment.ntpID,
+            providerPaymentId: payload.payment.ntpID,
+            externalReference: orderId,
+            providerPayload,
+        });
+        return {
+            action: "processing",
+            session: updated,
+            orderId,
+        };
+    }
+    if (callbackState === "completed") {
+        if (session.status === "paid" || session.status === "authorized") {
+            const current = await financeService.updatePaymentSession(db, session.id, {
+                provider: "netopia",
+                providerSessionId: payload.payment.ntpID,
+                providerPaymentId: payload.payment.ntpID,
+                externalReference: orderId,
+                providerPayload,
+            });
+            return {
+                action: "ignored",
+                reason: "already_completed",
+                session: current,
+                orderId,
+            };
+        }
+        const completed = await financeService.completePaymentSession(db, session.id, {
+            status: "paid",
+            captureMode: "manual",
+            paymentMethod: "credit_card",
+            providerSessionId: payload.payment.ntpID,
+            providerPaymentId: payload.payment.ntpID,
+            externalReference: orderId,
+            externalAuthorizationId: typeof payload.payment.data?.AuthCode === "string"
+                ? payload.payment.data.AuthCode
+                : payload.payment.ntpID,
+            externalCaptureId: typeof payload.payment.data?.RRN === "string"
+                ? payload.payment.data.RRN
+                : payload.payment.ntpID,
+            approvalCode: typeof payload.payment.data?.AuthCode === "string"
+                ? payload.payment.data.AuthCode
+                : undefined,
+            referenceNumber: typeof payload.payment.data?.RRN === "string" ? payload.payment.data.RRN : undefined,
+            authorizedAt: new Date().toISOString(),
+            capturedAt: new Date().toISOString(),
+            paymentDate: new Date().toISOString(),
+            providerPayload,
+        }, { eventBus: financeRuntime.eventBus });
+        return {
+            action: "completed",
+            session: completed,
+            orderId,
+        };
+    }
+    const failed = await financeService.failPaymentSession(db, session.id, {
+        providerSessionId: payload.payment.ntpID,
+        providerPaymentId: payload.payment.ntpID,
+        externalReference: orderId,
+        failureCode: typeof payload.payment.code === "string" && payload.payment.code.length > 0
+            ? payload.payment.code
+            : `netopia_status_${payload.payment.status}`,
+        failureMessage: typeof payload.payment.message === "string" && payload.payment.message.length > 0
+            ? payload.payment.message
+            : "Netopia payment was not approved",
+        providerPayload,
+    });
+    return {
+        action: "failed",
+        session: failed,
+        orderId,
+    };
+}

package/dist/service-collect.d.ts

@@ -0,0 +1,9 @@
+import { type NotificationService } from "@voyantjs/notifications";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { NetopiaClientApi } from "./client.js";
+import { type NetopiaCollectBookingGuaranteeInput, type NetopiaCollectBookingScheduleInput, type NetopiaCollectInvoiceInput, type NetopiaCollectPaymentResult } from "./service-shared.js";
+import type { NetopiaRuntimeOptions } from "./types.js";
+export declare function collectBookingSchedule(db: PostgresJsDatabase, scheduleId: string, input: NetopiaCollectBookingScheduleInput, runtimeOptions?: NetopiaRuntimeOptions, clientOverride?: NetopiaClientApi, dispatcherOverride?: NotificationService, bindings?: Record<string, unknown>): Promise<NetopiaCollectPaymentResult>;
+export declare function collectBookingGuarantee(db: PostgresJsDatabase, guaranteeId: string, input: NetopiaCollectBookingGuaranteeInput, runtimeOptions?: NetopiaRuntimeOptions, clientOverride?: NetopiaClientApi, dispatcherOverride?: NotificationService, bindings?: Record<string, unknown>): Promise<NetopiaCollectPaymentResult>;
+export declare function collectInvoice(db: PostgresJsDatabase, invoiceId: string, input: NetopiaCollectInvoiceInput, runtimeOptions?: NetopiaRuntimeOptions, clientOverride?: NetopiaClientApi, dispatcherOverride?: NotificationService, bindings?: Record<string, unknown>): Promise<NetopiaCollectPaymentResult>;
+//# sourceMappingURL=service-collect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-collect.d.ts","sourceRoot":"","sources":["../src/service-collect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAwB,MAAM,yBAAyB,CAAA;AACxF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAEL,KAAK,mCAAmC,EACxC,KAAK,kCAAkC,EACvC,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAEjC,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAEvD,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,kBAAkB,EACtB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,kCAAkC,EACzC,cAAc,GAAE,qBAA0B,EAC1C,cAAc,CAAC,EAAE,gBAAgB,EACjC,kBAAkB,CAAC,EAAE,mBAAmB,EACxC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,2BAA2B,CAAC,CAsCtC;AAED,wBAAsB,uBAAuB,CAC3C,EAAE,EAAE,kBAAkB,EACtB,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,mCAAmC,EAC1C,cAAc,GAAE,qBAA0B,EAC1C,cAAc,CAAC,EAAE,gBAAgB,EACjC,kBAAkB,CAAC,EAAE,mBAAmB,EACxC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,2BAA2B,CAAC,CAsCtC;AAED,wBAAsB,cAAc,CAClC,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,0BAA0B,EACjC,cAAc,GAAE,qBAA0B,EAC1C,cAAc,CAAC,EAAE,gBAAgB,EACjC,kBAAkB,CAAC,EAAE,mBAAmB,EACxC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,2BAA2B,CAAC,CAiDtC"}

package/dist/service-collect.js

@@ -0,0 +1,70 @@
+import { notificationsService } from "@voyantjs/notifications";
+import { financeService, resolveNotificationDispatcher, } from "./service-shared.js";
+import * as startService from "./service-start.js";
+export async function collectBookingSchedule(db, scheduleId, input, runtimeOptions = {}, clientOverride, dispatcherOverride, bindings) {
+    const session = await financeService.createPaymentSessionFromBookingSchedule(db, scheduleId, {
+        ...(input.paymentSession ?? {}),
+        provider: "netopia",
+    });
+    if (!session) {
+        throw new Error("Payment schedule not found");
+    }
+    const started = await startService.startPaymentSession(db, session.id, input.netopia, runtimeOptions, clientOverride, bindings);
+    const dispatcher = input.notification
+        ? resolveNotificationDispatcher(bindings, runtimeOptions, dispatcherOverride)
+        : null;
+    const paymentSessionNotification = input.notification && dispatcher
+        ? await notificationsService.sendPaymentSessionNotification(db, dispatcher, started.session.id, input.notification)
+        : null;
+    return {
+        ...started,
+        paymentSessionNotification,
+        invoiceNotification: null,
+    };
+}
+export async function collectBookingGuarantee(db, guaranteeId, input, runtimeOptions = {}, clientOverride, dispatcherOverride, bindings) {
+    const session = await financeService.createPaymentSessionFromBookingGuarantee(db, guaranteeId, {
+        ...(input.paymentSession ?? {}),
+        provider: "netopia",
+    });
+    if (!session) {
+        throw new Error("Booking guarantee not found");
+    }
+    const started = await startService.startPaymentSession(db, session.id, input.netopia, runtimeOptions, clientOverride, bindings);
+    const dispatcher = input.notification
+        ? resolveNotificationDispatcher(bindings, runtimeOptions, dispatcherOverride)
+        : null;
+    const paymentSessionNotification = input.notification && dispatcher
+        ? await notificationsService.sendPaymentSessionNotification(db, dispatcher, started.session.id, input.notification)
+        : null;
+    return {
+        ...started,
+        paymentSessionNotification,
+        invoiceNotification: null,
+    };
+}
+export async function collectInvoice(db, invoiceId, input, runtimeOptions = {}, clientOverride, dispatcherOverride, bindings) {
+    const session = await financeService.createPaymentSessionFromInvoice(db, invoiceId, {
+        ...(input.paymentSession ?? {}),
+        provider: "netopia",
+    });
+    if (!session) {
+        throw new Error("Invoice not found");
+    }
+    const started = await startService.startPaymentSession(db, session.id, input.netopia, runtimeOptions, clientOverride, bindings);
+    const shouldNotify = Boolean(input.paymentSessionNotification || input.invoiceNotification);
+    const dispatcher = shouldNotify
+        ? resolveNotificationDispatcher(bindings, runtimeOptions, dispatcherOverride)
+        : null;
+    const paymentSessionNotification = input.paymentSessionNotification && dispatcher
+        ? await notificationsService.sendPaymentSessionNotification(db, dispatcher, started.session.id, input.paymentSessionNotification)
+        : null;
+    const invoiceNotification = input.invoiceNotification && dispatcher
+        ? await notificationsService.sendInvoiceNotification(db, dispatcher, invoiceId, input.invoiceNotification)
+        : null;
+    return {
+        ...started,
+        paymentSessionNotification,
+        invoiceNotification,
+    };
+}

package/dist/service-shared.d.ts

@@ -0,0 +1,33 @@
+import { financeService, type PaymentSession } from "@voyantjs/finance";
+import type { NotificationDelivery, NotificationService } from "@voyantjs/notifications";
+import type { z } from "zod";
+import type { NetopiaProductLine, NetopiaRuntimeOptions, NetopiaStartPaymentResponse, ResolvedNetopiaRuntimeOptions } from "./types.js";
+import type { netopiaCollectBookingGuaranteeSchema, netopiaCollectBookingScheduleSchema, netopiaCollectInvoiceSchema } from "./validation.js";
+export interface NetopiaStartPaymentResult {
+    session: PaymentSession;
+    providerResponse: NetopiaStartPaymentResponse;
+    orderId: string;
+}
+export interface NetopiaCallbackResult {
+    action: "processing" | "completed" | "failed" | "ignored";
+    reason?: string;
+    session: PaymentSession | null;
+    orderId: string;
+}
+export interface NetopiaCollectPaymentResult extends NetopiaStartPaymentResult {
+    paymentSessionNotification: NotificationDelivery | null;
+    invoiceNotification: NotificationDelivery | null;
+}
+export type NetopiaCollectBookingScheduleInput = z.infer<typeof netopiaCollectBookingScheduleSchema>;
+export type NetopiaCollectBookingGuaranteeInput = z.infer<typeof netopiaCollectBookingGuaranteeSchema>;
+export type NetopiaCollectInvoiceInput = z.infer<typeof netopiaCollectInvoiceSchema>;
+export declare function centsToAmount(cents: number): number;
+export declare function amountToCents(amount: number): number;
+export declare function normalizeCurrency(currency: string): string;
+export declare function mergeRecord(base: Record<string, unknown> | null | undefined, extra: Record<string, unknown>): Record<string, unknown>;
+export declare function buildDefaultProducts(session: PaymentSession, description: string): NetopiaProductLine[];
+export declare function deriveNetopiaOrderId(session: PaymentSession): string;
+export declare function mapNetopiaPaymentStatus(status: number, options: Pick<ResolvedNetopiaRuntimeOptions, "successStatuses" | "processingStatuses">): "completed" | "processing" | "failed";
+export declare function resolveNotificationDispatcher(bindings: Record<string, unknown> | undefined, runtimeOptions: NetopiaRuntimeOptions, dispatcherOverride?: NotificationService): NotificationService;
+export { financeService };
+//# sourceMappingURL=service-shared.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-shared.d.ts","sourceRoot":"","sources":["../src/service-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AACxF,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAG5B,OAAO,KAAK,EACV,kBAAkB,EAClB,qBAAqB,EACrB,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EACV,oCAAoC,EACpC,mCAAmC,EACnC,2BAA2B,EAC5B,MAAM,iBAAiB,CAAA;AAExB,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,cAAc,CAAA;IACvB,gBAAgB,EAAE,2BAA2B,CAAA;IAC7C,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,YAAY,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,CAAA;IACzD,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9B,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,2BAA4B,SAAQ,yBAAyB;IAC5E,0BAA0B,EAAE,oBAAoB,GAAG,IAAI,CAAA;IACvD,mBAAmB,EAAE,oBAAoB,GAAG,IAAI,CAAA;CACjD;AAED,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,KAAK,CACvD,OAAO,oCAAoC,CAC5C,CAAA;AACD,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAEpF,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,UAE1C;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,UAE3C;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,UAEjD;AAED,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,EAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,MAAM,GAClB,kBAAkB,EAAE,CAQtB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,UAE3D;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,IAAI,CAAC,6BAA6B,EAAE,iBAAiB,GAAG,oBAAoB,CAAC,GACrF,WAAW,GAAG,YAAY,GAAG,QAAQ,CAIvC;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,cAAc,EAAE,qBAAqB,EACrC,kBAAkB,CAAC,EAAE,mBAAmB,uBAGzC;AAED,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/service-shared.js

@@ -0,0 +1,40 @@
+import { financeService } from "@voyantjs/finance";
+import { buildNetopiaNotificationRuntime } from "./notification-runtime.js";
+export function centsToAmount(cents) {
+    return Number((cents / 100).toFixed(2));
+}
+export function amountToCents(amount) {
+    return Math.round(amount * 100);
+}
+export function normalizeCurrency(currency) {
+    return currency.trim().toUpperCase();
+}
+export function mergeRecord(base, extra) {
+    return {
+        ...(base ?? {}),
+        ...extra,
+    };
+}
+export function buildDefaultProducts(session, description) {
+    return [
+        {
+            name: description,
+            price: centsToAmount(session.amountCents),
+            vat: 0,
+        },
+    ];
+}
+export function deriveNetopiaOrderId(session) {
+    return session.externalReference ?? session.clientReference ?? session.id;
+}
+export function mapNetopiaPaymentStatus(status, options) {
+    if (options.successStatuses.includes(status))
+        return "completed";
+    if (options.processingStatuses.includes(status))
+        return "processing";
+    return "failed";
+}
+export function resolveNotificationDispatcher(bindings, runtimeOptions, dispatcherOverride) {
+    return buildNetopiaNotificationRuntime(bindings, runtimeOptions, dispatcherOverride).dispatcher;
+}
+export { financeService };

package/dist/service-start.d.ts

@@ -0,0 +1,6 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { type NetopiaClientApi } from "./client.js";
+import { type NetopiaStartPaymentResult } from "./service-shared.js";
+import type { NetopiaRuntimeOptions, NetopiaStartPaymentInput } from "./types.js";
+export declare function startPaymentSession(db: PostgresJsDatabase, sessionId: string, input: NetopiaStartPaymentInput, runtimeOptions?: NetopiaRuntimeOptions, clientOverride?: NetopiaClientApi, bindings?: Record<string, unknown>): Promise<NetopiaStartPaymentResult>;
+//# sourceMappingURL=service-start.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-start.d.ts","sourceRoot":"","sources":["../src/service-start.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,OAAO,EAEL,KAAK,gBAAgB,EAEtB,MAAM,aAAa,CAAA;AACpB,OAAO,EAML,KAAK,yBAAyB,EAE/B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EAEzB,MAAM,YAAY,CAAA;AAEnB,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,kBAAkB,EACtB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,wBAAwB,EAC/B,cAAc,GAAE,qBAA0B,EAC1C,cAAc,CAAC,EAAE,gBAAgB,EACjC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,yBAAyB,CAAC,CA0FpC"}

package/dist/service-start.js

@@ -0,0 +1,81 @@
+import { createNetopiaClient, resolveNetopiaRuntimeOptions, } from "./client.js";
+import { buildDefaultProducts, centsToAmount, deriveNetopiaOrderId, financeService, mergeRecord, normalizeCurrency, } from "./service-shared.js";
+export async function startPaymentSession(db, sessionId, input, runtimeOptions = {}, clientOverride, bindings) {
+    const session = await financeService.getPaymentSessionById(db, sessionId);
+    if (!session) {
+        throw new Error("Payment session not found");
+    }
+    if (session.provider && session.provider !== "netopia") {
+        throw new Error(`Payment session ${sessionId} is already assigned to provider "${session.provider}"`);
+    }
+    if (["paid", "authorized", "cancelled", "expired"].includes(session.status)) {
+        throw new Error(`Payment session ${sessionId} is not startable from status "${session.status}"`);
+    }
+    const runtime = resolveNetopiaRuntimeOptions(bindings, runtimeOptions);
+    const client = clientOverride ??
+        createNetopiaClient({
+            apiUrl: runtime.apiUrl,
+            apiKey: runtime.apiKey,
+            fetch: runtime.fetch,
+        });
+    const description = input.description ?? session.notes ?? `Payment ${session.id}`;
+    const orderId = deriveNetopiaOrderId(session);
+    const request = {
+        config: {
+            emailTemplate: input.emailTemplate ?? runtime.emailTemplate,
+            notifyUrl: input.notifyUrl ?? runtime.notifyUrl,
+            redirectUrl: input.returnUrl ?? runtime.redirectUrl,
+            language: input.language ?? runtime.language,
+        },
+        payment: {
+            options: input.options ?? { installments: 1 },
+            instrument: input.instrument,
+            data: input.browserData,
+        },
+        order: {
+            ntpID: "",
+            posSignature: runtime.posSignature,
+            dateTime: new Date().toISOString(),
+            description,
+            orderID: orderId,
+            amount: centsToAmount(session.amountCents),
+            currency: normalizeCurrency(session.currency),
+            billing: input.billing,
+            shipping: input.shipping ?? input.billing,
+            products: input.products && input.products.length > 0
+                ? input.products
+                : buildDefaultProducts(session, description),
+            installments: input.installments ?? { selected: 1, available: [0] },
+            data: input.orderData,
+        },
+    };
+    const providerResponse = await client.startCardPayment(request);
+    const payment = providerResponse.payment;
+    if (!payment?.paymentURL) {
+        throw new Error("Netopia start payment succeeded without paymentURL");
+    }
+    const updated = await financeService.markPaymentSessionRequiresRedirect(db, session.id, {
+        provider: "netopia",
+        providerSessionId: payment.ntpID ?? null,
+        providerPaymentId: payment.ntpID ?? null,
+        externalReference: orderId,
+        redirectUrl: payment.paymentURL,
+        returnUrl: input.returnUrl ?? runtime.redirectUrl,
+        cancelUrl: input.cancelUrl ?? null,
+        callbackUrl: input.callbackUrl ?? input.notifyUrl ?? runtime.notifyUrl,
+        providerPayload: mergeRecord(session.providerPayload, {
+            netopiaStartRequest: request,
+            netopiaStartResponse: providerResponse,
+        }),
+        metadata: input.metadata ?? undefined,
+        notes: input.notes ?? session.notes ?? undefined,
+    });
+    if (!updated) {
+        throw new Error("Payment session disappeared while saving Netopia redirect state");
+    }
+    return {
+        session: updated,
+        providerResponse,
+        orderId,
+    };
+}

package/dist/service.d.ts

@@ -0,0 +1,13 @@
+import { handleCallback } from "./service-callback.js";
+import { collectBookingGuarantee, collectBookingSchedule, collectInvoice } from "./service-collect.js";
+import { deriveNetopiaOrderId, mapNetopiaPaymentStatus, type NetopiaCallbackResult, type NetopiaCollectPaymentResult, type NetopiaStartPaymentResult } from "./service-shared.js";
+import { startPaymentSession } from "./service-start.js";
+export { deriveNetopiaOrderId, mapNetopiaPaymentStatus, type NetopiaCallbackResult, type NetopiaCollectPaymentResult, type NetopiaStartPaymentResult, };
+export declare const netopiaService: {
+    startPaymentSession: typeof startPaymentSession;
+    collectBookingSchedule: typeof collectBookingSchedule;
+    collectBookingGuarantee: typeof collectBookingGuarantee;
+    collectInvoice: typeof collectInvoice;
+    handleCallback: typeof handleCallback;
+};
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,EACL,uBAAuB,EACvB,sBAAsB,EACtB,cAAc,EACf,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,EAC/B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AAExD,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,yBAAyB,GAC/B,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;CAM1B,CAAA"}

package/dist/service.js

@@ -0,0 +1,12 @@
+import { handleCallback } from "./service-callback.js";
+import { collectBookingGuarantee, collectBookingSchedule, collectInvoice, } from "./service-collect.js";
+import { deriveNetopiaOrderId, mapNetopiaPaymentStatus, } from "./service-shared.js";
+import { startPaymentSession } from "./service-start.js";
+export { deriveNetopiaOrderId, mapNetopiaPaymentStatus, };
+export const netopiaService = {
+    startPaymentSession,
+    collectBookingSchedule,
+    collectBookingGuarantee,
+    collectInvoice,
+    handleCallback,
+};