@voyantjs/plugin-netopia 0.1.0

package/dist/src/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAKjE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AASvD,KAAK,GAAG,GAAG;IACT,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,wBAAgB,0BAA0B,CAAC,OAAO,GAAE,qBAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCAsI7E;AAOD,wBAAgB,6BAA6B,CAAC,OAAO,GAAE,qBAA0B,GAAG,aAAa,CAKhG;AAED,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,qBAA0B,GAAG,UAAU,CAMjF;AAED,eAAO,MAAM,uBAAuB,eAAkC,CAAA"}

package/dist/src/plugin.js

@@ -0,0 +1,127 @@
+import { defineHonoPlugin } 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 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 };
+    };
+    return new Hono()
+        .post("/providers/netopia/payment-sessions/:sessionId/start", async (c) => {
+        try {
+            const data = netopiaStartPaymentSessionSchema.parse(await c.req.json());
+            const result = await netopiaService.startPaymentSession(c.get("db"), c.req.param("sessionId"), data, options, undefined, c.env);
+            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 = netopiaCollectBookingScheduleSchema.parse(await c.req.json());
+            const result = await netopiaService.collectBookingSchedule(c.get("db"), c.req.param("scheduleId"), data, options, 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 = netopiaCollectBookingGuaranteeSchema.parse(await c.req.json());
+            const result = await netopiaService.collectBookingGuarantee(c.get("db"), c.req.param("guaranteeId"), data, options, 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 = netopiaCollectInvoiceSchema.parse(await c.req.json());
+            const result = await netopiaService.collectInvoice(c.get("db"), c.req.param("invoiceId"), data, options, 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 = netopiaWebhookPayloadSchema.parse(await c.req.json());
+        const result = await netopiaService.handleCallback(c.get("db"), payload, options, c.env);
+        return c.json({ data: result });
+    })
+        .get("/providers/netopia/config", async (c) => {
+        try {
+            const runtime = resolveNetopiaRuntimeOptions(c.env, options);
+            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 netopiaHonoPlugin(options = {}) {
+    return defineHonoPlugin({
+        name: "netopia",
+        version: "0.1.0",
+        extensions: [createNetopiaFinanceExtension(options)],
+    });
+}
+export const netopiaFinanceExtension = createNetopiaFinanceExtension();

package/dist/src/service.d.ts

@@ -0,0 +1,36 @@
+import { type PaymentSession } from "@voyantjs/finance";
+import { type NotificationDelivery, type NotificationService } from "@voyantjs/notifications";
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { z } from "zod";
+import { type NetopiaClientApi } from "./client.js";
+import type { NetopiaRuntimeOptions, NetopiaStartPaymentInput, NetopiaStartPaymentResponse, NetopiaWebhookPayload, 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;
+}
+type NetopiaCollectBookingScheduleInput = z.infer<typeof netopiaCollectBookingScheduleSchema>;
+type NetopiaCollectBookingGuaranteeInput = z.infer<typeof netopiaCollectBookingGuaranteeSchema>;
+type NetopiaCollectInvoiceInput = z.infer<typeof netopiaCollectInvoiceSchema>;
+export declare function deriveNetopiaOrderId(session: PaymentSession): string;
+export declare function mapNetopiaPaymentStatus(status: number, options: Pick<ResolvedNetopiaRuntimeOptions, "successStatuses" | "processingStatuses">): "completed" | "processing" | "failed";
+export declare const netopiaService: {
+    startPaymentSession(db: PostgresJsDatabase, sessionId: string, input: NetopiaStartPaymentInput, runtimeOptions?: NetopiaRuntimeOptions, clientOverride?: NetopiaClientApi, bindings?: Record<string, unknown>): Promise<NetopiaStartPaymentResult>;
+    collectBookingSchedule(db: PostgresJsDatabase, scheduleId: string, input: NetopiaCollectBookingScheduleInput, runtimeOptions?: NetopiaRuntimeOptions, clientOverride?: NetopiaClientApi, dispatcherOverride?: NotificationService, bindings?: Record<string, unknown>): Promise<NetopiaCollectPaymentResult>;
+    collectBookingGuarantee(db: PostgresJsDatabase, guaranteeId: string, input: NetopiaCollectBookingGuaranteeInput, runtimeOptions?: NetopiaRuntimeOptions, clientOverride?: NetopiaClientApi, dispatcherOverride?: NotificationService, bindings?: Record<string, unknown>): Promise<NetopiaCollectPaymentResult>;
+    collectInvoice(db: PostgresJsDatabase, invoiceId: string, input: NetopiaCollectInvoiceInput, runtimeOptions?: NetopiaRuntimeOptions, clientOverride?: NetopiaClientApi, dispatcherOverride?: NotificationService, bindings?: Record<string, unknown>): Promise<NetopiaCollectPaymentResult>;
+    handleCallback(db: PostgresJsDatabase, payload: NetopiaWebhookPayload, runtimeOptions?: NetopiaRuntimeOptions, bindings?: Record<string, unknown>): Promise<NetopiaCallbackResult>;
+};
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/src/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACzB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,EAAqD,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACtG,OAAO,KAAK,EACV,qBAAqB,EACrB,wBAAwB,EAExB,2BAA2B,EAC3B,qBAAqB,EAErB,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,KAAK,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC7F,KAAK,mCAAmC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AAC/F,KAAK,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAkC7E,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;AAiBD,eAAO,MAAM,cAAc;4BAEnB,kBAAkB,aACX,MAAM,SACV,wBAAwB,mBACf,qBAAqB,mBACpB,gBAAgB,aACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,yBAAyB,CAAC;+BA2F/B,kBAAkB,cACV,MAAM,SACX,kCAAkC,mBACzB,qBAAqB,mBACpB,gBAAgB,uBACZ,mBAAmB,aAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,2BAA2B,CAAC;gCAyCjC,kBAAkB,eACT,MAAM,SACZ,mCAAmC,mBAC1B,qBAAqB,mBACpB,gBAAgB,uBACZ,mBAAmB,aAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,2BAA2B,CAAC;uBAyCjC,kBAAkB,aACX,MAAM,SACV,0BAA0B,mBACjB,qBAAqB,mBACpB,gBAAgB,uBACZ,mBAAmB,aAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,2BAA2B,CAAC;uBAoDjC,kBAAkB,WACb,qBAAqB,mBACd,qBAAqB,aAC1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACjC,OAAO,CAAC,qBAAqB,CAAC;CA8IlC,CAAA"}

package/dist/src/service.js

@@ -0,0 +1,313 @@
+import { financeService } from "@voyantjs/finance";
+import { createDefaultNotificationProviders, createNotificationService, notificationsService, } from "@voyantjs/notifications";
+import { createNetopiaClient, resolveNetopiaRuntimeOptions } from "./client.js";
+function centsToAmount(cents) {
+    return Number((cents / 100).toFixed(2));
+}
+function amountToCents(amount) {
+    return Math.round(amount * 100);
+}
+function normalizeCurrency(currency) {
+    return currency.trim().toUpperCase();
+}
+function mergeRecord(base, extra) {
+    return {
+        ...(base ?? {}),
+        ...extra,
+    };
+}
+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";
+}
+function resolveNotificationDispatcher(bindings, runtimeOptions, dispatcherOverride) {
+    if (dispatcherOverride) {
+        return dispatcherOverride;
+    }
+    return createNotificationService(runtimeOptions.resolveNotificationProviders?.(bindings ?? {}) ??
+        createDefaultNotificationProviders(bindings ?? {}));
+}
+export const netopiaService = {
+    async 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,
+        };
+    },
+    async 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 this.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,
+        };
+    },
+    async 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 this.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,
+        };
+    },
+    async 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 this.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,
+        };
+    },
+    async handleCallback(db, payload, runtimeOptions = {}, bindings) {
+        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,
+        });
+        const normalizedCurrency = normalizeCurrency(payload.payment.currency);
+        const amountCents = amountToCents(payload.payment.amount);
+        if (callbackState === "completed" &&
+            (normalizedCurrency !== normalizeCurrency(session.currency) || amountCents !== session.amountCents)) {
+            const failed = await financeService.failPaymentSession(db, session.id, {
+                providerSessionId: payload.payment.ntpID,
+                providerPaymentId: payload.payment.ntpID,
+                externalReference: orderId,
+                failureCode: "amount_or_currency_mismatch",
+                failureMessage: `Expected ${session.amountCents} ${normalizeCurrency(session.currency)}, received ${amountCents} ${normalizedCurrency}`,
+                providerPayload,
+            });
+            return {
+                action: "failed",
+                reason: "amount_or_currency_mismatch",
+                session: failed,
+                orderId,
+            };
+        }
+        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,
+            });
+            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/src/types.d.ts

@@ -0,0 +1,160 @@
+import type { NotificationProvider } from "@voyantjs/notifications";
+export type NetopiaFetch = (input: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+}) => Promise<{
+    ok: boolean;
+    status: number;
+    json: () => Promise<unknown>;
+    text: () => Promise<string>;
+}>;
+export interface NetopiaBillingAddress {
+    email: string;
+    phone: string;
+    firstName: string;
+    lastName: string;
+    city: string;
+    country: number;
+    state: string;
+    postalCode: string;
+    details: string;
+}
+export interface NetopiaProductLine {
+    name?: string;
+    code?: string;
+    category?: string;
+    price?: number;
+    vat?: number;
+}
+export interface NetopiaInstallments {
+    selected: number;
+    available: number[];
+}
+export interface NetopiaPaymentOptions {
+    installments: number;
+    bonus?: number;
+}
+export interface NetopiaPaymentInstrument {
+    type: string;
+    account: string;
+    expMonth: number;
+    expYear: number;
+    secretCode: string;
+    token?: string;
+}
+export interface NetopiaBrowserData {
+    [key: string]: string | undefined;
+}
+export interface NetopiaStartPaymentRequest {
+    config: {
+        emailTemplate: string;
+        notifyUrl: string;
+        redirectUrl: string;
+        language: string;
+    };
+    payment: {
+        options: NetopiaPaymentOptions;
+        instrument?: NetopiaPaymentInstrument;
+        data?: NetopiaBrowserData;
+    };
+    order: {
+        ntpID?: string;
+        posSignature: string;
+        dateTime: string;
+        description: string;
+        orderID: string;
+        amount: number;
+        currency: string;
+        billing: NetopiaBillingAddress;
+        shipping: NetopiaBillingAddress;
+        products: NetopiaProductLine[];
+        installments: NetopiaInstallments;
+        data?: Record<string, string>;
+    };
+}
+export interface NetopiaStartPaymentResponse {
+    code?: string;
+    message?: string;
+    error?: {
+        code?: string | number;
+        message?: string;
+    };
+    payment?: {
+        paymentURL?: string;
+        ntpID?: string;
+        status?: number;
+        amount?: number;
+        currency?: string;
+    };
+}
+export interface NetopiaWebhookPayload {
+    order: {
+        orderID: string;
+    };
+    payment: {
+        amount: number;
+        currency: string;
+        ntpID: string;
+        status: number;
+        code?: string;
+        message?: string;
+        data?: {
+            AuthCode?: string;
+            RRN?: string;
+            [key: string]: unknown;
+        };
+        instrument?: {
+            country?: number;
+            panMasked?: string;
+            [key: string]: unknown;
+        };
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export interface NetopiaStartPaymentInput {
+    description?: string;
+    notifyUrl?: string;
+    returnUrl?: string;
+    cancelUrl?: string;
+    callbackUrl?: string;
+    emailTemplate?: string;
+    language?: string;
+    options?: NetopiaPaymentOptions;
+    instrument?: NetopiaPaymentInstrument;
+    browserData?: NetopiaBrowserData;
+    billing: NetopiaBillingAddress;
+    shipping?: NetopiaBillingAddress;
+    products?: NetopiaProductLine[];
+    installments?: NetopiaInstallments;
+    orderData?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    notes?: string | null;
+}
+export interface NetopiaRuntimeOptions {
+    apiUrl?: string;
+    apiKey?: string;
+    posSignature?: string;
+    notifyUrl?: string;
+    redirectUrl?: string;
+    emailTemplate?: string;
+    language?: string;
+    successStatuses?: number[];
+    processingStatuses?: number[];
+    fetch?: NetopiaFetch;
+    resolveNotificationProviders?: (bindings: Record<string, unknown>) => ReadonlyArray<NotificationProvider>;
+}
+export interface ResolvedNetopiaRuntimeOptions {
+    apiUrl: string;
+    apiKey: string;
+    posSignature: string;
+    notifyUrl: string;
+    redirectUrl: string;
+    emailTemplate: string;
+    language: string;
+    successStatuses: number[];
+    processingStatuses: number[];
+    fetch?: NetopiaFetch;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};