@webbers/pay-payments-medusa 1.0.0

package/.medusa/server/src/providers/pay/core/pay-base.js

@@ -0,0 +1,561 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const pay_client_1 = require("./pay-client");
+const crypto_1 = __importDefault(require("crypto"));
+const constants_1 = require("./constants");
+const getExpirationForPaymentMethod_1 = __importDefault(require("../utils/getExpirationForPaymentMethod"));
+/**
+ * Implementation of Pay. Payment Provider for Medusa
+ */
+class PayBase extends utils_1.AbstractPaymentProvider {
+    /**
+     * Validates that the required options are provided
+     * @param options - The options to validate
+     * @throws {MedusaError} If required config is missing
+     */
+    static validateOptions(options) {
+        if (!options.atCode ||
+            !options.apiToken ||
+            !options.slCode ||
+            !options.slSecret ||
+            !options.returnUrl ||
+            !options.medusaUrl) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "AT Code, API Token, SL Code, SL Secret, Return URL & Medusa URL are required in the provider's options.");
+        }
+    }
+    /**
+     * Creates a new instance of the Pay. payment provider
+     * @param container - The dependency container
+     * @param options - Configuration options
+     */
+    constructor(container, options) {
+        super(container, options);
+        this.getPaymentDescription = (order) => {
+            const language = order.metadata?.locale;
+            const paymentDescriptions = this.options_?.paymentDescription;
+            const displayId = order.display_id.toString();
+            let description = order.sales_channel?.name
+                ? `${order.sales_channel.name} - #${displayId}`
+                : `#${displayId}`;
+            if (paymentDescriptions) {
+                description =
+                    language && paymentDescriptions?.[language]
+                        ? paymentDescriptions[language]
+                        : (paymentDescriptions?.default ?? "[display_id]");
+                description = description.replace("[display_id]", displayId);
+            }
+            return description;
+        };
+        this.logger_ = container.logger;
+        this.options_ = options;
+        this.debug_ =
+            options.testMode ||
+                process.env.NODE_ENV === "development" ||
+                process.env.NODE_ENV === "test" ||
+                false;
+        this.client_ = new pay_client_1.PayClient(options, this.logger_);
+    }
+    createPayOrderPayload(order, session_id, paymentMethodInput) {
+        const currency = order.currency_code.toUpperCase();
+        const products = order.items.map((item) => ({
+            id: item.variant_sku || item.variant_id || item.id,
+            description: `${item.product_title} - ${item.variant_title}`,
+            type: "ARTICLE",
+            price: {
+                value: Math.round((item.original_total.valueOf() / item.quantity) * 100),
+                currency,
+            },
+            quantity: item.quantity,
+            vatPercentage: item.tax_lines?.[0]?.rate,
+        }));
+        const discount = order.discount_total.valueOf() * 100;
+        if (discount > 0) {
+            products.push({
+                type: "DISCOUNT",
+                id: "DISCOUNT",
+                description: "Discount",
+                price: {
+                    value: discount * -1,
+                    currency,
+                },
+                quantity: 1,
+            });
+        }
+        const shippingTotal = order.shipping_total.valueOf() * 100;
+        if (shippingTotal > 0) {
+            products.push({
+                type: "SHIPPING",
+                id: "SHIPPING",
+                description: "Shipping",
+                price: {
+                    value: shippingTotal,
+                    currency,
+                },
+                quantity: 1,
+            });
+        }
+        let paymentMethod;
+        if (this.paymentCreateOptions.method_id) {
+            paymentMethod = {
+                id: this.paymentCreateOptions.method_id,
+                input: paymentMethodInput,
+            };
+        }
+        const payload = {
+            reference: order.display_id.toString(),
+            description: this.getPaymentDescription(order),
+            paymentMethod,
+            returnUrl: this.options_.returnUrl,
+            expire: paymentMethod
+                ? (0, getExpirationForPaymentMethod_1.default)(paymentMethod)
+                : undefined,
+            exchangeUrl: this.paymentCreateOptions.webhookUrl,
+            transferData: {
+                session_id,
+            },
+            amount: {
+                value: Math.round(order.total.valueOf() * 100),
+                currency,
+            },
+            customer: {
+                firstname: order.customer?.first_name || order.billing_address?.first_name,
+                lastname: order.customer?.last_name || order.billing_address?.last_name,
+                ipAddress: order.metadata?.ip,
+                phone: order.customer?.phone || order.billing_address?.phone,
+                email: order.email,
+                locale: order.metadata?.locale?.toString()?.toUpperCase() ?? "EN",
+                reference: order.customer?.id,
+            },
+            order: {
+                countryCode: order.billing_address?.country_code?.toUpperCase(),
+                invoiceAddress: {
+                    firstName: order.billing_address?.first_name,
+                    lastName: order.billing_address?.last_name,
+                    street: order.billing_address?.address_1,
+                    streetNumber: order.billing_address?.address_2,
+                    zipCode: order.billing_address?.postal_code,
+                    city: order.billing_address?.city,
+                    country: order.billing_address?.country_code?.toUpperCase(),
+                },
+                deliveryAddress: {
+                    firstName: order.shipping_address?.first_name,
+                    lastName: order.shipping_address?.last_name,
+                    street: order.shipping_address?.address_1,
+                    streetNumber: order.shipping_address?.address_2,
+                    zipCode: order.shipping_address?.postal_code,
+                    city: order.shipping_address?.city,
+                    country: order.shipping_address?.country_code?.toUpperCase(),
+                },
+                products,
+            },
+        };
+        if (this.options_.testMode) {
+            try {
+                this.logger_.debug(JSON.stringify(payload));
+            }
+            catch (e) { }
+        }
+        return payload;
+    }
+    /**
+     * Initiates a new payment with Pay.
+     * @param input - The payment initiation input
+     * @returns The initiated payment details
+     */
+    async initiatePayment({ context, amount, data, currency_code, }) {
+        return {
+            data: { session_id: data?.session_id },
+            id: crypto_1.default.randomUUID(),
+        };
+    }
+    /**
+     * Authorize the Pay. payment
+     * @param input - The payment authorization input
+     * @returns The authorization result
+     */
+    async authorizePayment(input) {
+        console.log("authorizePayment", input);
+        if (input.data?.orderId) {
+            const { status } = await this.getPaymentStatus(input);
+            return { data: input.data, status };
+        }
+        return { data: input.data, status: utils_1.PaymentSessionStatus.AUTHORIZED };
+    }
+    /**
+     * Captures an authorized payment if autoCapture is disabled
+     * @param input - The payment capture input
+     * @returns The capture result
+     */
+    async capturePayment(input) {
+        console.log("capturePayment", input);
+        const id = input.data?.orderId;
+        if (!id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Payment ID is required");
+        }
+        try {
+            const { data } = (await this.retrievePayment({
+                data: {
+                    id,
+                },
+            }));
+            // If the Pay order is set to authorize we need to capture the order in Pay.
+            if (data?.status?.code === constants_1.PayPaymentStatus.AUTHORIZE) {
+                await this.client_.captureOrder(id);
+            }
+            const status = await this.getPaymentStatus({
+                data: {
+                    id,
+                },
+            }).then((res) => res.status);
+            if (status !== utils_1.PaymentSessionStatus.CAPTURED) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Payment is not captured: current status is ${status}`);
+            }
+            this.debug_ &&
+                this.logger_.info(`Pay. payment ${id} captured with amount ${(input.data?.amount).currency_code} ${(input.data?.amount).value}`);
+            const payment = await this.retrievePayment({
+                data: {
+                    id,
+                },
+            });
+            return {
+                data: payment.data,
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error capturing payment ${id}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Refunds a payment
+     * @param input - The payment refund input
+     * @returns The refund result
+     */
+    async refundPayment(input) {
+        console.log("refundPayment", input);
+        const id = input.data?.orderId;
+        if (!id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Payment ID is required");
+        }
+        try {
+            const payment = await this.retrievePayment({
+                data: {
+                    id,
+                },
+            });
+            const value = (input.data?.amount).value;
+            const currency = payment.data?.amount
+                ?.currency;
+            if (!currency) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Currency information is missing from payment data");
+            }
+            const refund = await this.client_.refundPayment(id, {
+                amount: {
+                    value: parseInt(value.toString()) * 100,
+                    currency: currency.toUpperCase(),
+                },
+            });
+            this.debug_ &&
+                this.logger_.info(`Refund for Pay. payment ${id} created with amount ${currency.toUpperCase()} ${parseFloat(value.toString()).toFixed(2)}`);
+            return {
+                data: { ...refund },
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error refunding payment ${id}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Cancels a payment
+     * @param input - The payment cancellation input
+     * @returns The cancellation result
+     */
+    async cancelPayment(input) {
+        console.log("cancelPayment", input);
+        const id = input.data?.orderId;
+        if (!id) {
+            return {};
+        }
+        try {
+            const payment = await this.client_.getOrder(id);
+            if (payment.status.code === constants_1.PayPaymentStatus.EXPIRED) {
+                this.debug_ &&
+                    this.logger_.info(`Pay. payment ${id} is already expired, no need to cancel`);
+                return {
+                    data: {
+                        id,
+                    },
+                };
+            }
+            const newPayment = await this.client_.abortOrder(id).catch((error) => {
+                this.logger_.warn(`Could not cancel Pay. payment ${id}: ${error.message}`);
+                return { data: payment };
+            });
+            this.debug_ &&
+                this.logger_.info(`Pay. payment ${id} cancelled successfully`);
+            return {
+                data: newPayment,
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error cancelling payment ${id}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Deletes a payment (equivalent to cancellation as Pay. does not support deletion)
+     * @param input - The payment deletion input
+     * @returns The deletion result
+     */
+    async deletePayment(input) {
+        console.log("deletePayment", input);
+        return this.cancelPayment(input);
+    }
+    /**
+     * Gets the status of a payment by mapping Pay. statuses to Medusa statuses
+     * @param input - The payment status input
+     * @returns The payment status
+     */
+    async getPaymentStatus(input) {
+        console.log("getPaymentStatus", input);
+        const id = input.data?.id;
+        try {
+            const { status } = await this.client_.getTransaction(id);
+            /**
+             * Also see Pay. status codes: https://developer.pay.nl/docs/transaction-statuses#after-processing-statuses
+             * Pay. payments should always go to authorized, so we can continue creating the order.
+             * This is required for Buy-now-pay-later options, where it can take some time before
+             * a paid status is reached.
+             */
+            const statusMap = {
+                [constants_1.PayPaymentStatus.INIT]: utils_1.PaymentSessionStatus.PENDING,
+                //[PayPaymentStatus.PENDING_20]: PaymentSessionStatus.REQUIRES_MORE,
+                [constants_1.PayPaymentStatus.PENDING_50]: utils_1.PaymentSessionStatus.PENDING,
+                [constants_1.PayPaymentStatus.PENDING_90]: utils_1.PaymentSessionStatus.PENDING,
+                [constants_1.PayPaymentStatus.PENDING_98]: utils_1.PaymentSessionStatus.PENDING,
+                [constants_1.PayPaymentStatus.CANCEL]: utils_1.PaymentSessionStatus.CANCELED,
+                [constants_1.PayPaymentStatus.EXPIRED]: utils_1.PaymentSessionStatus.CANCELED,
+                [constants_1.PayPaymentStatus.DENIED_64]: utils_1.PaymentSessionStatus.CANCELED,
+                [constants_1.PayPaymentStatus.DENIED_63]: utils_1.PaymentSessionStatus.CANCELED,
+                [constants_1.PayPaymentStatus.CANCEL_61]: utils_1.PaymentSessionStatus.CANCELED,
+                [constants_1.PayPaymentStatus.FAILURE]: utils_1.PaymentSessionStatus.ERROR,
+                [constants_1.PayPaymentStatus.PAID_CHECKAMOUNT]: utils_1.PaymentSessionStatus.ERROR,
+                [constants_1.PayPaymentStatus.PARTIAL_PAYMENT]: utils_1.PaymentSessionStatus.REQUIRES_MORE,
+                [constants_1.PayPaymentStatus.VERIFY]: utils_1.PaymentSessionStatus.PENDING,
+                [constants_1.PayPaymentStatus.AUTHORIZE]: utils_1.PaymentSessionStatus.AUTHORIZED,
+                [constants_1.PayPaymentStatus.PARTLY_CAPTURED]: utils_1.PaymentSessionStatus.REQUIRES_MORE,
+                [constants_1.PayPaymentStatus.PAID]: utils_1.PaymentSessionStatus.CAPTURED,
+                [constants_1.PayPaymentStatus.CHARGEBACK]: utils_1.PaymentSessionStatus.CANCELED,
+            };
+            const mappedStatus = statusMap[status.code];
+            this.debug_ &&
+                this.logger_.debug(`Pay. payment ${id} status: ${status} (mapped to: ${mappedStatus})`);
+            return {
+                status: mappedStatus,
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error retrieving payment status for ${id}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Retrieves payment details
+     * @param input - The payment retrieval input
+     * @returns The payment details
+     */
+    async retrievePayment(input) {
+        console.log("retrievePayment", input);
+        const id = input.data?.id;
+        try {
+            let data;
+            // Check if the order ID starts with a 2, in that case we will need to use the legacy Pay API.
+            if (id.startsWith("2")) {
+                data = await this.client_.getTransaction(id);
+            }
+            else {
+                data = await this.client_.getOrder(id);
+            }
+            return {
+                data: data,
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error retrieving Pay. payment ${id}: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Updates the Pay. order object
+     * @param input - The payment update input
+     * @returns The updated payment details
+     */
+    async updatePayment(input) {
+        console.log("updatePayment", input);
+        // If the Pay data is passed from the order created hook, only then we update
+        // the session data.
+        const payload = input.data?.payload;
+        if (payload) {
+            try {
+                const data = await this.client_.createOrder(payload).catch((error) => {
+                    this.logger_.error(`Pay. payment creation failed: ${error.message}`);
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, error.message);
+                });
+                this.debug_ &&
+                    this.logger_.info(`Pay. payment ${data.id} successfully created with amount ${payload.amount.currency} ${payload.amount.value}`);
+                return { data: data };
+            }
+            catch (error) {
+                this.logger_.error(`Error initiating Pay. payment: ${error.message}`);
+                throw error;
+            }
+        }
+        return { data: {} };
+    }
+    get keyMap() {
+        return {
+            [this.options_.atCode]: this.options_.apiToken,
+            [this.options_.slCode]: this.options_.slSecret,
+            ...(this.options_.otherSlCodes ? this.options_.otherSlCodes : {}),
+        };
+    }
+    /**
+     * Processes webhook data from Pay.
+     * @param payload - The webhook payload
+     * @returns The action and data to be processed
+     */
+    async getWebhookActionAndData(payload) {
+        const { data, rawData, headers } = payload;
+        try {
+            let payment = null;
+            // For the legacy Pay. webhooks no header signature can be done and only
+            // order_id should be used to retrieve the payment.
+            if (data.action === "new_ppt") {
+                const { data: paymentData } = (await this.retrievePayment({
+                    data: {
+                        id: data.order_id,
+                    },
+                }).catch((e) => {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, e.message);
+                }));
+                if (!payment) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Payment not found");
+                }
+                payment = paymentData;
+            }
+            else {
+                // For new webhooks from Pay., check the signature. If valid, the payload
+                // will already contain the payment object, so no additional retrieval
+                // of the payment is required.
+                const signatureMethod = headers["signature-method"];
+                const signatureKeyId = headers["signature-keyid"];
+                const signatureAlgorithm = headers["signature-algorithm"] ?? "sha256";
+                const signature = headers["signature"];
+                const secret = this.keyMap[signatureKeyId];
+                if (signatureMethod !== "HMAC") {
+                    throw new utils_1.MedusaError(utils_1.MedusaErrorTypes.INVALID_DATA, "Invalid signature method");
+                }
+                if (!secret) {
+                    throw new utils_1.MedusaError(utils_1.MedusaErrorTypes.INVALID_DATA, `No secret key not found for ${signatureKeyId}`);
+                }
+                const hmac = crypto_1.default.createHmac(signatureAlgorithm, secret);
+                const calculatedSignature = hmac.update(rawData).digest("hex");
+                if (calculatedSignature !== signature) {
+                    throw new utils_1.MedusaError(utils_1.MedusaErrorTypes.INVALID_DATA, "Invalid signature");
+                }
+                if (this.debug_) {
+                    try {
+                        this.logger_.debug(JSON.stringify(data));
+                    }
+                    catch (e) { }
+                }
+                if (data.type === "order") {
+                    payment = data.object;
+                }
+            }
+            if (!payment) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "Payment not found");
+            }
+            const baseData = {
+                session_id: payment.transferData.session_id,
+                amount: payment.amount.value / 100,
+            };
+            console.log("payment.status.code", payment.status.code);
+            console.log("baseData", baseData);
+            switch (payment.status.code) {
+                case constants_1.PayPaymentStatus.PAID:
+                    return {
+                        action: utils_1.PaymentActions.SUCCESSFUL,
+                        data: baseData,
+                    };
+                case constants_1.PayPaymentStatus.INIT:
+                case constants_1.PayPaymentStatus.PENDING_20:
+                case constants_1.PayPaymentStatus.PENDING_50:
+                case constants_1.PayPaymentStatus.PENDING_90:
+                case constants_1.PayPaymentStatus.PENDING_98:
+                case constants_1.PayPaymentStatus.VERIFY:
+                    return {
+                        action: utils_1.PaymentActions.PENDING,
+                        data: baseData,
+                    };
+                case constants_1.PayPaymentStatus.CANCEL:
+                case constants_1.PayPaymentStatus.EXPIRED:
+                case constants_1.PayPaymentStatus.DENIED_64:
+                case constants_1.PayPaymentStatus.DENIED_63:
+                case constants_1.PayPaymentStatus.CANCEL_61:
+                case constants_1.PayPaymentStatus.CHARGEBACK:
+                    return {
+                        action: utils_1.PaymentActions.CANCELED,
+                        data: baseData,
+                    };
+                case constants_1.PayPaymentStatus.FAILURE:
+                case constants_1.PayPaymentStatus.PAID_CHECKAMOUNT:
+                    return {
+                        action: utils_1.PaymentActions.FAILED,
+                        data: baseData,
+                    };
+                case constants_1.PayPaymentStatus.PARTIAL_PAYMENT:
+                case constants_1.PayPaymentStatus.PARTLY_CAPTURED:
+                    return {
+                        action: utils_1.PaymentActions.REQUIRES_MORE,
+                        data: baseData,
+                    };
+                case constants_1.PayPaymentStatus.AUTHORIZE:
+                    return {
+                        action: utils_1.PaymentActions.AUTHORIZED,
+                        data: baseData,
+                    };
+                default:
+                    return {
+                        action: utils_1.PaymentActions.NOT_SUPPORTED,
+                        data: baseData,
+                    };
+            }
+        }
+        catch (error) {
+            this.logger_.error(`Error processing webhook for payment ${data.id}: ${error.message}`);
+            // Even with errors, try to construct a valid response if we have the payment
+            const { data: payment } = await this.retrievePayment({
+                data: { id: data.orderId },
+            }).catch(() => ({ data: null }));
+            if (payment) {
+                return {
+                    action: "failed",
+                    data: {
+                        session_id: payment?.metadata?.session_id,
+                        amount: new BigNumber(payment?.amount),
+                        ...payment,
+                    },
+                };
+            }
+            throw error;
+        }
+    }
+}
+exports.default = PayBase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pay-base.js","sourceRoot":"","sources":["../../../../../../src/providers/pay/core/pay-base.ts"],"names":[],"mappings":"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"}