@voyantjs/plugin-netopia 0.1.1 → 0.3.0

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

@@ -1,254 +0,0 @@
-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

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

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

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

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

@@ -1,346 +0,0 @@
-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();
-    });
-});