@voyantjs/plugin-netopia 0.1.0

package/dist/tests/unit/client.test.js

@@ -0,0 +1,254 @@
+import { describe, expect, it, vi } from "vitest";
+import { createNetopiaClient, resolveNetopiaRuntimeOptions } from "../../src/client.js";
+function jsonResponse(status, body) {
+    const text = JSON.stringify(body);
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        json: async () => JSON.parse(text),
+        text: async () => text,
+    };
+}
+function textResponse(status, text) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        json: async () => {
+            throw new Error("not json");
+        },
+        text: async () => text,
+    };
+}
+describe("resolveNetopiaRuntimeOptions", () => {
+    it("merges env bindings with defaults", () => {
+        const options = resolveNetopiaRuntimeOptions({
+            NETOPIA_URL: "https://secure.mobilpay.ro/pay",
+            NETOPIA_API_KEY: "api-key",
+            NETOPIA_POS_SIGNATURE: "pos-signature",
+            NETOPIA_NOTIFY_URL: "https://api.example.com/netopia/callback",
+            NETOPIA_REDIRECT_URL: "https://app.example.com/checkout/return",
+        });
+        expect(options.language).toBe("ro");
+        expect(options.emailTemplate).toBe("confirm");
+        expect(options.successStatuses).toEqual([3, 5]);
+    });
+    it("throws when required config is missing", () => {
+        expect(() => resolveNetopiaRuntimeOptions({})).toThrow(/NETOPIA_URL/);
+    });
+});
+describe("createNetopiaClient.startCardPayment", () => {
+    it("posts to /payment/card/start with Authorization header", async () => {
+        const fetchMock = vi.fn(async () => jsonResponse(200, {
+            payment: { paymentURL: "https://secure.example.com/pay", ntpID: "ntp_123", status: 1 },
+        }));
+        const client = createNetopiaClient({
+            apiUrl: "https://secure.mobilpay.ro/pay/",
+            apiKey: "api-key",
+            fetch: fetchMock,
+        });
+        const response = await client.startCardPayment({
+            config: {
+                emailTemplate: "confirm",
+                notifyUrl: "https://api.example.com/callback",
+                redirectUrl: "https://app.example.com/return",
+                language: "ro",
+            },
+            payment: {
+                options: { installments: 1 },
+            },
+            order: {
+                posSignature: "pos-signature",
+                dateTime: new Date().toISOString(),
+                description: "Tour deposit",
+                orderID: "pmss_123",
+                amount: 125,
+                currency: "RON",
+                billing: {
+                    email: "traveler@example.com",
+                    phone: "0712345678",
+                    firstName: "Ana",
+                    lastName: "Popescu",
+                    city: "Bucharest",
+                    country: 40,
+                    state: "B",
+                    postalCode: "010101",
+                    details: "Str. Exemplu 1",
+                },
+                shipping: {
+                    email: "traveler@example.com",
+                    phone: "0712345678",
+                    firstName: "Ana",
+                    lastName: "Popescu",
+                    city: "Bucharest",
+                    country: 40,
+                    state: "B",
+                    postalCode: "010101",
+                    details: "Str. Exemplu 1",
+                },
+                products: [{ name: "Tour deposit", price: 125, vat: 0 }],
+                installments: { selected: 1, available: [0] },
+            },
+        });
+        expect(response.payment?.ntpID).toBe("ntp_123");
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toBe("https://secure.mobilpay.ro/pay/payment/card/start");
+        expect(init.method).toBe("POST");
+        expect(init.headers.Authorization).toBe("api-key");
+    });
+    it("throws on provider error payload", async () => {
+        const fetchMock = vi.fn(async () => jsonResponse(200, { error: { code: "bad_request", message: "No merchant" } }));
+        const client = createNetopiaClient({
+            apiUrl: "https://secure.mobilpay.ro/pay",
+            apiKey: "api-key",
+            fetch: fetchMock,
+        });
+        await expect(client.startCardPayment({
+            config: {
+                emailTemplate: "confirm",
+                notifyUrl: "https://api.example.com/callback",
+                redirectUrl: "https://app.example.com/return",
+                language: "ro",
+            },
+            payment: {
+                options: { installments: 1 },
+            },
+            order: {
+                posSignature: "pos-signature",
+                dateTime: new Date().toISOString(),
+                description: "Tour deposit",
+                orderID: "pmss_123",
+                amount: 125,
+                currency: "RON",
+                billing: {
+                    email: "traveler@example.com",
+                    phone: "0712345678",
+                    firstName: "Ana",
+                    lastName: "Popescu",
+                    city: "Bucharest",
+                    country: 40,
+                    state: "B",
+                    postalCode: "010101",
+                    details: "Str. Exemplu 1",
+                },
+                shipping: {
+                    email: "traveler@example.com",
+                    phone: "0712345678",
+                    firstName: "Ana",
+                    lastName: "Popescu",
+                    city: "Bucharest",
+                    country: 40,
+                    state: "B",
+                    postalCode: "010101",
+                    details: "Str. Exemplu 1",
+                },
+                products: [{ name: "Tour deposit", price: 125, vat: 0 }],
+                installments: { selected: 1, available: [0] },
+            },
+        })).rejects.toThrow(/Netopia start payment failed/);
+    });
+    it("throws when fetch is unavailable", async () => {
+        const originalFetch = globalThis.fetch;
+        globalThis.fetch = undefined;
+        try {
+            // biome-ignore lint/suspicious/noExplicitAny: test stub
+            const client = createNetopiaClient({ apiUrl: "https://secure.mobilpay.ro/pay", apiKey: "api-key", fetch: undefined });
+            await expect(client.startCardPayment({
+                config: {
+                    emailTemplate: "confirm",
+                    notifyUrl: "https://api.example.com/callback",
+                    redirectUrl: "https://app.example.com/return",
+                    language: "ro",
+                },
+                payment: {
+                    options: { installments: 1 },
+                },
+                order: {
+                    posSignature: "pos-signature",
+                    dateTime: new Date().toISOString(),
+                    description: "Tour deposit",
+                    orderID: "pmss_123",
+                    amount: 125,
+                    currency: "RON",
+                    billing: {
+                        email: "traveler@example.com",
+                        phone: "0712345678",
+                        firstName: "Ana",
+                        lastName: "Popescu",
+                        city: "Bucharest",
+                        country: 40,
+                        state: "B",
+                        postalCode: "010101",
+                        details: "Str. Exemplu 1",
+                    },
+                    shipping: {
+                        email: "traveler@example.com",
+                        phone: "0712345678",
+                        firstName: "Ana",
+                        lastName: "Popescu",
+                        city: "Bucharest",
+                        country: 40,
+                        state: "B",
+                        postalCode: "010101",
+                        details: "Str. Exemplu 1",
+                    },
+                    products: [{ name: "Tour deposit", price: 125, vat: 0 }],
+                    installments: { selected: 1, available: [0] },
+                },
+            })).rejects.toThrow(/requires a fetch implementation/);
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+        }
+    });
+    it("surfaces non-2xx HTTP failures", async () => {
+        const fetchMock = vi.fn(async () => textResponse(500, "gateway error"));
+        const client = createNetopiaClient({
+            apiUrl: "https://secure.mobilpay.ro/pay",
+            apiKey: "api-key",
+            fetch: fetchMock,
+        });
+        await expect(client.startCardPayment({
+            config: {
+                emailTemplate: "confirm",
+                notifyUrl: "https://api.example.com/callback",
+                redirectUrl: "https://app.example.com/return",
+                language: "ro",
+            },
+            payment: {
+                options: { installments: 1 },
+            },
+            order: {
+                posSignature: "pos-signature",
+                dateTime: new Date().toISOString(),
+                description: "Tour deposit",
+                orderID: "pmss_123",
+                amount: 125,
+                currency: "RON",
+                billing: {
+                    email: "traveler@example.com",
+                    phone: "0712345678",
+                    firstName: "Ana",
+                    lastName: "Popescu",
+                    city: "Bucharest",
+                    country: 40,
+                    state: "B",
+                    postalCode: "010101",
+                    details: "Str. Exemplu 1",
+                },
+                shipping: {
+                    email: "traveler@example.com",
+                    phone: "0712345678",
+                    firstName: "Ana",
+                    lastName: "Popescu",
+                    city: "Bucharest",
+                    country: 40,
+                    state: "B",
+                    postalCode: "010101",
+                    details: "Str. Exemplu 1",
+                },
+                products: [{ name: "Tour deposit", price: 125, vat: 0 }],
+                installments: { selected: 1, available: [0] },
+            },
+        })).rejects.toThrow(/\(500\)/);
+    });
+});

package/dist/tests/unit/plugin.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugin.test.d.ts.map

package/dist/tests/unit/plugin.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/plugin.test.ts"],"names":[],"mappings":""}

package/dist/tests/unit/plugin.test.js

@@ -0,0 +1,346 @@
+import { financeService } from "@voyantjs/finance";
+import { notificationsService } from "@voyantjs/notifications";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { deriveNetopiaOrderId, mapNetopiaPaymentStatus, netopiaService } from "../../src/service.js";
+const baseSession = {
+    id: "pmss_123",
+    targetType: "booking",
+    targetId: "book_123",
+    bookingId: "book_123",
+    orderId: null,
+    invoiceId: null,
+    bookingPaymentScheduleId: null,
+    bookingGuaranteeId: null,
+    paymentInstrumentId: null,
+    paymentAuthorizationId: null,
+    paymentCaptureId: null,
+    paymentId: null,
+    status: "pending",
+    provider: null,
+    providerSessionId: null,
+    providerPaymentId: null,
+    externalReference: null,
+    idempotencyKey: null,
+    clientReference: "client_ref_123",
+    currency: "RON",
+    amountCents: 12500,
+    paymentMethod: null,
+    payerPersonId: null,
+    payerOrganizationId: null,
+    payerEmail: "traveler@example.com",
+    payerName: "Ana Popescu",
+    redirectUrl: null,
+    returnUrl: null,
+    cancelUrl: null,
+    callbackUrl: null,
+    expiresAt: null,
+    completedAt: null,
+    failedAt: null,
+    cancelledAt: null,
+    expiredAt: null,
+    failureCode: null,
+    failureMessage: null,
+    notes: "Tour deposit",
+    providerPayload: null,
+    metadata: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+};
+const runtimeOptions = {
+    apiUrl: "https://secure.mobilpay.ro/pay",
+    apiKey: "api-key",
+    posSignature: "pos-signature",
+    notifyUrl: "https://api.example.com/netopia/callback",
+    redirectUrl: "https://app.example.com/checkout/return",
+};
+const billingInput = {
+    email: "traveler@example.com",
+    phone: "0712345678",
+    firstName: "Ana",
+    lastName: "Popescu",
+    city: "Bucharest",
+    country: 40,
+    state: "B",
+    postalCode: "010101",
+    details: "Str. Exemplu 1",
+};
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe("deriveNetopiaOrderId", () => {
+    it("prefers externalReference, then clientReference, then session id", () => {
+        expect(deriveNetopiaOrderId({ ...baseSession, externalReference: "external_1" })).toBe("external_1");
+        expect(deriveNetopiaOrderId(baseSession)).toBe("client_ref_123");
+        expect(deriveNetopiaOrderId({ ...baseSession, clientReference: null })).toBe("pmss_123");
+    });
+});
+describe("mapNetopiaPaymentStatus", () => {
+    const config = { successStatuses: [3, 5], processingStatuses: [1, 15] };
+    it("maps success statuses", () => {
+        expect(mapNetopiaPaymentStatus(3, config)).toBe("completed");
+        expect(mapNetopiaPaymentStatus(5, config)).toBe("completed");
+    });
+    it("maps in-flight statuses", () => {
+        expect(mapNetopiaPaymentStatus(1, config)).toBe("processing");
+        expect(mapNetopiaPaymentStatus(15, config)).toBe("processing");
+    });
+    it("treats everything else as failed", () => {
+        expect(mapNetopiaPaymentStatus(12, config)).toBe("failed");
+    });
+});
+describe("netopiaService.startPaymentSession", () => {
+    it("starts a hosted payment and persists redirect state", async () => {
+        vi.spyOn(financeService, "getPaymentSessionById").mockResolvedValue(baseSession);
+        const updated = {
+            ...baseSession,
+            provider: "netopia",
+            status: "requires_redirect",
+            externalReference: "client_ref_123",
+            providerSessionId: "ntp_123",
+            redirectUrl: "https://secure.example.com/pay",
+        };
+        const markSpy = vi
+            .spyOn(financeService, "markPaymentSessionRequiresRedirect")
+            .mockResolvedValue(updated);
+        const client = {
+            startCardPayment: vi.fn(async () => ({
+                payment: {
+                    paymentURL: "https://secure.example.com/pay",
+                    ntpID: "ntp_123",
+                    status: 1,
+                    amount: 125,
+                    currency: "RON",
+                },
+            })),
+        };
+        const result = await netopiaService.startPaymentSession({}, baseSession.id, {
+            billing: {
+                email: "traveler@example.com",
+                phone: "0712345678",
+                firstName: "Ana",
+                lastName: "Popescu",
+                city: "Bucharest",
+                country: 40,
+                state: "B",
+                postalCode: "010101",
+                details: "Str. Exemplu 1",
+            },
+        }, {
+            ...runtimeOptions,
+        }, client);
+        expect(result.orderId).toBe("client_ref_123");
+        expect(markSpy).toHaveBeenCalledWith({}, baseSession.id, expect.objectContaining({
+            provider: "netopia",
+            providerSessionId: "ntp_123",
+            redirectUrl: "https://secure.example.com/pay",
+        }));
+    });
+});
+describe("netopiaService.collect flows", () => {
+    it("creates, starts, and notifies for a booking schedule collection", async () => {
+        const createdSession = {
+            ...baseSession,
+            targetType: "booking_payment_schedule",
+            targetId: "bpms_123",
+            bookingPaymentScheduleId: "bpms_123",
+            provider: "netopia",
+        };
+        vi.spyOn(financeService, "createPaymentSessionFromBookingSchedule").mockResolvedValue(createdSession);
+        const started = {
+            session: {
+                ...createdSession,
+                status: "requires_redirect",
+                redirectUrl: "https://pay.example",
+            },
+            providerResponse: { payment: { paymentURL: "https://pay.example", ntpID: "ntp_123" } },
+            orderId: "order_123",
+        };
+        vi.spyOn(netopiaService, "startPaymentSession").mockResolvedValue(started);
+        const notifySpy = vi
+            .spyOn(notificationsService, "sendPaymentSessionNotification")
+            .mockResolvedValue({ id: "ntdl_123" });
+        const result = await netopiaService.collectBookingSchedule({}, "bpms_123", {
+            paymentSession: { payerEmail: "traveler@example.com" },
+            netopia: { billing: billingInput },
+            notification: {
+                channel: "email",
+                templateSlug: "payment-link",
+                subject: "Pay now",
+            },
+        }, runtimeOptions, undefined, {});
+        expect(financeService.createPaymentSessionFromBookingSchedule).toHaveBeenCalledWith({}, "bpms_123", expect.objectContaining({
+            provider: "netopia",
+            payerEmail: "traveler@example.com",
+        }));
+        expect(notifySpy).toHaveBeenCalledWith({}, {}, started.session.id, expect.objectContaining({
+            templateSlug: "payment-link",
+        }));
+        expect(result.paymentSessionNotification?.id).toBe("ntdl_123");
+    });
+    it("creates, starts, and can send both invoice and payment-session notifications", async () => {
+        const createdSession = {
+            ...baseSession,
+            targetType: "invoice",
+            targetId: "inv_123",
+            invoiceId: "inv_123",
+            provider: "netopia",
+        };
+        vi.spyOn(financeService, "createPaymentSessionFromInvoice").mockResolvedValue(createdSession);
+        const started = {
+            session: {
+                ...createdSession,
+                status: "requires_redirect",
+                redirectUrl: "https://pay.example",
+            },
+            providerResponse: { payment: { paymentURL: "https://pay.example", ntpID: "ntp_123" } },
+            orderId: "INV-123",
+        };
+        vi.spyOn(netopiaService, "startPaymentSession").mockResolvedValue(started);
+        const paymentNotifySpy = vi
+            .spyOn(notificationsService, "sendPaymentSessionNotification")
+            .mockResolvedValue({ id: "ntdl_pay_123" });
+        const invoiceNotifySpy = vi
+            .spyOn(notificationsService, "sendInvoiceNotification")
+            .mockResolvedValue({ id: "ntdl_inv_123" });
+        const result = await netopiaService.collectInvoice({}, "inv_123", {
+            paymentSession: { payerEmail: "traveler@example.com" },
+            netopia: { billing: billingInput },
+            paymentSessionNotification: {
+                channel: "email",
+                templateSlug: "payment-link",
+                subject: "Complete payment",
+            },
+            invoiceNotification: {
+                channel: "email",
+                templateSlug: "invoice-issued",
+                subject: "Invoice ready",
+            },
+        }, runtimeOptions, undefined, {});
+        expect(financeService.createPaymentSessionFromInvoice).toHaveBeenCalledWith({}, "inv_123", expect.objectContaining({
+            provider: "netopia",
+        }));
+        expect(paymentNotifySpy).toHaveBeenCalledTimes(1);
+        expect(invoiceNotifySpy).toHaveBeenCalledWith({}, {}, "inv_123", expect.objectContaining({
+            templateSlug: "invoice-issued",
+        }));
+        expect(result.paymentSessionNotification?.id).toBe("ntdl_pay_123");
+        expect(result.invoiceNotification?.id).toBe("ntdl_inv_123");
+    });
+});
+describe("netopiaService.handleCallback", () => {
+    it("completes a successful callback exactly once", async () => {
+        vi.spyOn(financeService, "listPaymentSessions").mockResolvedValue({
+            data: [{ ...baseSession, provider: "netopia", externalReference: "client_ref_123" }],
+            total: 1,
+            limit: 1,
+            offset: 0,
+        });
+        const completeSpy = vi.spyOn(financeService, "completePaymentSession").mockResolvedValue({
+            ...baseSession,
+            provider: "netopia",
+            status: "paid",
+            externalReference: "client_ref_123",
+            providerSessionId: "ntp_123",
+            providerPaymentId: "ntp_123",
+        });
+        const result = await netopiaService.handleCallback({}, {
+            order: { orderID: "client_ref_123" },
+            payment: {
+                amount: 125,
+                currency: "RON",
+                ntpID: "ntp_123",
+                status: 3,
+                data: { AuthCode: "AUTH1", RRN: "RRN1" },
+            },
+        }, runtimeOptions);
+        expect(result.action).toBe("completed");
+        expect(completeSpy).toHaveBeenCalledTimes(1);
+    });
+    it("marks in-flight statuses as processing", async () => {
+        vi.spyOn(financeService, "listPaymentSessions").mockResolvedValue({
+            data: [{ ...baseSession, provider: "netopia", externalReference: "client_ref_123" }],
+            total: 1,
+            limit: 1,
+            offset: 0,
+        });
+        const updateSpy = vi.spyOn(financeService, "updatePaymentSession").mockResolvedValue({
+            ...baseSession,
+            provider: "netopia",
+            status: "processing",
+            externalReference: "client_ref_123",
+        });
+        const result = await netopiaService.handleCallback({}, {
+            order: { orderID: "client_ref_123" },
+            payment: {
+                amount: 125,
+                currency: "RON",
+                ntpID: "ntp_123",
+                status: 1,
+            },
+        }, runtimeOptions);
+        expect(result.action).toBe("processing");
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+    });
+    it("fails when callback amount does not match the stored session", async () => {
+        vi.spyOn(financeService, "listPaymentSessions").mockResolvedValue({
+            data: [{ ...baseSession, provider: "netopia", externalReference: "client_ref_123" }],
+            total: 1,
+            limit: 1,
+            offset: 0,
+        });
+        const failSpy = vi.spyOn(financeService, "failPaymentSession").mockResolvedValue({
+            ...baseSession,
+            provider: "netopia",
+            status: "failed",
+            externalReference: "client_ref_123",
+        });
+        const result = await netopiaService.handleCallback({}, {
+            order: { orderID: "client_ref_123" },
+            payment: {
+                amount: 999,
+                currency: "RON",
+                ntpID: "ntp_123",
+                status: 3,
+            },
+        }, runtimeOptions);
+        expect(result.action).toBe("failed");
+        expect(failSpy).toHaveBeenCalledWith({}, baseSession.id, expect.objectContaining({
+            failureCode: "amount_or_currency_mismatch",
+        }));
+    });
+    it("treats duplicate success callbacks as idempotent", async () => {
+        vi.spyOn(financeService, "listPaymentSessions").mockResolvedValue({
+            data: [
+                {
+                    ...baseSession,
+                    provider: "netopia",
+                    status: "paid",
+                    externalReference: "client_ref_123",
+                },
+            ],
+            total: 1,
+            limit: 1,
+            offset: 0,
+        });
+        const updateSpy = vi.spyOn(financeService, "updatePaymentSession").mockResolvedValue({
+            ...baseSession,
+            provider: "netopia",
+            status: "paid",
+            externalReference: "client_ref_123",
+        });
+        const completeSpy = vi.spyOn(financeService, "completePaymentSession");
+        const result = await netopiaService.handleCallback({}, {
+            order: { orderID: "client_ref_123" },
+            payment: {
+                amount: 125,
+                currency: "RON",
+                ntpID: "ntp_123",
+                status: 5,
+            },
+        }, runtimeOptions);
+        expect(result.action).toBe("ignored");
+        expect(result.reason).toBe("already_completed");
+        expect(updateSpy).toHaveBeenCalledTimes(1);
+        expect(completeSpy).not.toHaveBeenCalled();
+    });
+});

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@voyantjs/plugin-netopia",
+  "version": "0.1.0",
+  "license": "FSL-1.1-Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
+    },
+    "./service": {
+      "types": "./dist/service.d.ts",
+      "import": "./dist/service.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js"
+    },
+    "./validation": {
+      "types": "./dist/validation.d.ts",
+      "import": "./dist/validation.js"
+    }
+  },
+  "dependencies": {
+    "drizzle-orm": "^0.45.2",
+    "hono": "^4.12.10",
+    "zod": "^4.3.6",
+    "@voyantjs/hono": "0.1.0",
+    "@voyantjs/core": "0.1.0",
+    "@voyantjs/notifications": "0.1.0",
+    "@voyantjs/finance": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2",
+    "@voyantjs/voyant-typescript-config": "0.1.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check src/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}