@enomshop/paystack 1.0.7 → 1.0.9

package/.medusa/server/src/jobs/sync-paystack-payments.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = syncPaystackPayments;
+const utils_1 = require("@medusajs/framework/utils");
+const paystack_1 = __importDefault(require("../lib/paystack"));
+// Helper to prevent hitting Paystack rate limits
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function syncPaystackPayments(container) {
+    const paymentModuleService = container.resolve(utils_1.Modules.PAYMENT);
+    const logger = container.resolve("logger");
+    logger.info("Starting Paystack payment sync...");
+    try {
+        // @ts-ignore
+        const payments = await paymentModuleService.listPayments({
+            id: "pp_paystack",
+        });
+        // 2. Filter for pending payments that are OLDER than 15 minutes
+        // This prevents race conditions with incoming webhooks
+        const fifteenMinutesAgo = new Date(Date.now() - 15 * 60 * 1000);
+        const pendingPayments = payments.filter((p) => !p.captured_at &&
+            !p.canceled_at &&
+            p.created_at && new Date(p.created_at) < fifteenMinutesAgo);
+        if (pendingPayments.length === 0) {
+            logger.info("No stale pending Paystack payments found.");
+            return;
+        }
+        logger.info(`Found ${pendingPayments.length} stale payments to verify.`);
+        // Initialize Paystack client
+        const paystack = new paystack_1.default(process.env.PAYSTACK_SECRET_KEY);
+        for (const payment of pendingPayments) {
+            try {
+                const txRef = payment.data?.paystackTxRef;
+                if (!txRef)
+                    continue;
+                // 3. Verify transaction status with Paystack
+                const { data, status } = await paystack.transaction.verify(txRef);
+                if (status && data.status === "success") {
+                    logger.info(`Capturing payment ${payment.id} from Paystack sync`);
+                    // 4. Capture the payment in Medusa
+                    await paymentModuleService.capturePayment({
+                        payment_id: payment.id,
+                        amount: payment.amount,
+                    });
+                }
+                else if (status && (data.status === "failed" || data.status === "abandoned")) {
+                    logger.info(`Canceling failed/abandoned payment ${payment.id} from Paystack sync`);
+                    // Optional: You can cancel the payment in Medusa to clean up the database
+                    // await paymentModuleService.cancelPayment(payment.id);
+                }
+                // 5. Sleep for 200ms to respect Paystack API rate limits (approx 5 req/sec)
+                await sleep(200);
+            }
+            catch (error) {
+                logger.error(`Error syncing Paystack payment ${payment.id}:`, error);
+            }
+        }
+    }
+    catch (error) {
+        logger.error("Error running Paystack payment sync job:", error);
+    }
+}
+exports.config = {
+    name: "sync-paystack-payments",
+    schedule: "*/15 * * * *", // Runs every 15 minutes
+};
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/lib/paystack.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PAYSTACK_API_PATH = void 0;
+const axios_1 = __importDefault(require("axios"));
+const axios_retry_1 = __importDefault(require("axios-retry"));
+exports.PAYSTACK_API_PATH = "https://api.paystack.co";
+class Paystack {
+    constructor(apiKey, options) {
+        this.transaction = {
+            get: ({ id }) => this.requestPaystackAPI({
+                path: "/transaction/" + id,
+                method: "GET",
+            }),
+            list: (query) => this.requestPaystackAPI({
+                path: "/transaction",
+                method: "GET",
+                query: query,
+            }),
+            balance: () => this.requestPaystackAPI({
+                path: "/balance",
+                method: "GET",
+            }),
+            verify: (reference) => this.requestPaystackAPI({
+                path: "/transaction/verify/" + reference,
+                method: "GET",
+            }),
+            totals: () => this.requestPaystackAPI({
+                path: "/transaction/totals",
+                method: "GET",
+            }),
+            initialize: ({ amount, email, currency, reference, callback_url, metadata, }) => this.requestPaystackAPI({
+                path: "/transaction/initialize",
+                method: "POST",
+                body: {
+                    amount,
+                    email,
+                    currency,
+                    reference,
+                    callback_url,
+                    metadata: metadata ? JSON.stringify(metadata) : undefined,
+                },
+            }),
+        };
+        this.refund = {
+            create: ({ transaction, amount, }) => this.requestPaystackAPI({
+                path: "/refund",
+                method: "POST",
+                body: {
+                    transaction,
+                    amount,
+                },
+            }),
+        };
+        this.customer = {
+            create: (data) => this.requestPaystackAPI({
+                path: "/customer",
+                method: "POST",
+                body: data, // Cast to match your Request interface expectations
+            }),
+            update: (customerCode, data) => this.requestPaystackAPI({
+                path: `/customer/${customerCode}`,
+                method: "PUT",
+                body: data,
+            }),
+        };
+        this.apiKey = apiKey;
+        this.axiosInstance = axios_1.default.create({
+            baseURL: exports.PAYSTACK_API_PATH,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (options?.disable_retries !== true) {
+            (0, axios_retry_1.default)(this.axiosInstance, {
+                retries: 3,
+                // Enables retries on network errors, idempotent http methods, and 5xx errors
+                retryCondition: axios_retry_1.default.isNetworkOrIdempotentRequestError,
+                // Exponential backoff with jitter
+                retryDelay: axios_retry_1.default.exponentialDelay,
+            });
+        }
+    }
+    async requestPaystackAPI(request) {
+        const options = {
+            method: request.method,
+            url: request.path,
+            params: request.query,
+            data: request.body,
+        };
+        try {
+            const res = await this.axiosInstance(options);
+            return res.data;
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                throw new Error(`Error from Paystack API with status code ${error.response?.status}: ${error.response?.data?.message}`);
+            }
+            throw error;
+        }
+    }
+}
+exports.default = Paystack;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/providers/paystack/index.js

@@ -0,0 +1,11 @@
+"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 paystack_payment_processor_1 = __importDefault(require("../../services/paystack-payment-processor"));
+exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.PAYMENT, {
+    services: [paystack_payment_processor_1.default],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3BheXN0YWNrL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7O0FBQUEscURBQW9FO0FBQ3BFLDJHQUFpRjtBQUVqRixrQkFBZSxJQUFBLHNCQUFjLEVBQUMsZUFBTyxDQUFDLE9BQU8sRUFBRTtJQUM3QyxRQUFRLEVBQUUsQ0FBQyxvQ0FBd0IsQ0FBQztDQUNyQyxDQUFDLENBQUMifQ==

package/.medusa/server/src/services/paystack-payment-processor.js

@@ -0,0 +1,350 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const paystack_1 = __importDefault(require("../lib/paystack"));
+const utils_1 = require("@medusajs/framework/utils");
+const currencyCode_1 = require("../utils/currencyCode");
+class PaystackPaymentProcessor extends utils_1.AbstractPaymentProvider {
+    constructor(cradle, options) {
+        super(cradle, options);
+        if (!options.secret_key) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, "The Paystack provider requires the secret_key option");
+        }
+        this.configuration = options;
+        this.paystack = new paystack_1.default(this.configuration.secret_key, {
+            disable_retries: options.disable_retries,
+        });
+        this.debug = Boolean(options.debug);
+        this.logger = cradle.logger;
+    }
+    async initiatePayment(initiatePaymentData) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: InitiatePayment ${JSON.stringify(initiatePaymentData, null, 2)}`);
+        }
+        const { data, amount, currency_code } = initiatePaymentData;
+        const { email, session_id, order_id, callback_url, ...customMetadata } = (data ?? {});
+        const validatedCurrencyCode = (0, currencyCode_1.formatCurrencyCode)(currency_code);
+        const SUPPORTED_CURRENCIES = ["NGN", "GHS", "ZAR", "USD", "KES", "EGP", "RWF"];
+        if (!SUPPORTED_CURRENCIES.includes(validatedCurrencyCode)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Currency ${validatedCurrencyCode} is not supported by Paystack. Supported currencies are: ${SUPPORTED_CURRENCIES.join(", ")}`);
+        }
+        if (!email) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, "Email is required to initiate a Paystack payment. Ensure you are providing the email in the context object when calling `initiatePaymentSession` in your Medusa storefront");
+        }
+        // FIX: Multiply amount by 100 for subunits
+        const paystackAmount = Math.round(Number(amount) * 100);
+        // FIX: Generate a custom reference
+        const reference = customMetadata?.reference || `TX${Date.now().toString().slice(-8)}${Math.floor(100 + Math.random() * 900)}`;
+        try {
+            const { data: psData, status, message, } = await this.paystack.transaction.initialize({
+                amount: paystackAmount,
+                email,
+                currency: validatedCurrencyCode,
+                reference,
+                callback_url,
+                metadata: {
+                    session_id,
+                    order_id,
+                    ...customMetadata,
+                },
+            });
+            if (status === false) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to initiate Paystack payment", message);
+            }
+            return {
+                id: psData.reference,
+                status: utils_1.PaymentSessionStatus.PENDING,
+                data: {
+                    paystackTxRef: psData.reference,
+                    paystackTxAccessCode: psData.access_code,
+                    paystackTxAuthorizationUrl: psData.authorization_url,
+                },
+            };
+        }
+        catch (error) {
+            if (this.debug) {
+                this.logger.error("PS_P_Debug: InitiatePayment: Error", error);
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to initiate Paystack payment", error?.toString() ?? "Unknown error");
+        }
+    }
+    async createAccountHolder(input) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: createAccountHolder ${JSON.stringify(input, null, 2)}`);
+        }
+        const { customer } = input.context || {};
+        if (!customer?.email) {
+            return { id: `ps_mock_${Date.now()}` };
+        }
+        try {
+            const { data, status, message } = await this.paystack.customer.create({
+                email: customer.email,
+                first_name: customer.first_name ?? undefined,
+                last_name: customer.last_name ?? undefined,
+                phone: customer.phone ?? undefined,
+            });
+            if (status === false) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, message || "Paystack API Error");
+            }
+            return { id: data.customer_code };
+        }
+        catch (error) {
+            if (this.debug) {
+                this.logger.error("PS_P_Debug: createAccountHolder: Error", error);
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to create Paystack customer", error?.toString() ?? "Unknown error");
+        }
+    }
+    async updateAccountHolder(input) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: updateAccountHolder ${JSON.stringify(input, null, 2)}`);
+        }
+        const { account_holder, customer } = input.context || {};
+        const customerCode = account_holder?.data?.id;
+        if (!customerCode || !customerCode.startsWith("CUS_") || !customer) {
+            return { id: customerCode || `ps_mock_${Date.now()}` };
+        }
+        try {
+            const { status, message } = await this.paystack.customer.update(customerCode, {
+                first_name: customer.first_name ?? undefined,
+                last_name: customer.last_name ?? undefined,
+                phone: customer.phone ?? undefined,
+            });
+            if (status === false) {
+                if (this.debug) {
+                    this.logger.error(`PS_P_Debug: updateAccountHolder API Error: ${message}`);
+                }
+            }
+            return { id: customerCode };
+        }
+        catch (error) {
+            if (this.debug) {
+                this.logger.error("PS_P_Debug: updateAccountHolder: Error", error);
+            }
+            return { id: customerCode };
+        }
+    }
+    async deleteAccountHolder(input) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: deleteAccountHolder ${JSON.stringify(input, null, 2)}`);
+        }
+        return;
+    }
+    async updatePayment(input) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: UpdatePayment ${JSON.stringify(input, null, 2)}`);
+        }
+        const session = await this.initiatePayment(input);
+        return {
+            data: session.data,
+            status: session.status,
+        };
+    }
+    async authorizePayment(input) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: AuthorizePayment ${JSON.stringify(input, null, 2)}`);
+        }
+        try {
+            const { paystackTxRef } = input.data;
+            if (!paystackTxRef) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Missing paystackTxRef in payment data.");
+            }
+            const { status: psStatus, data } = await this.paystack.transaction.verify(paystackTxRef);
+            if (this.debug) {
+                this.logger.info(`PS_P_Debug: AuthorizePayment: Verification ${JSON.stringify({ psStatus, data }, null, 2)}`);
+            }
+            if (psStatus === false) {
+                return {
+                    status: utils_1.PaymentSessionStatus.ERROR,
+                    data: {
+                        ...input.data,
+                        paystackTxId: data.id,
+                        paystackTxData: data,
+                    },
+                };
+            }
+            switch (data.status) {
+                case "success":
+                    return {
+                        status: utils_1.PaymentSessionStatus.AUTHORIZED,
+                        data: {
+                            ...input.data,
+                            paystackTxId: data.id,
+                            paystackTxData: data,
+                        },
+                    };
+                case "failed":
+                    return {
+                        status: utils_1.PaymentSessionStatus.ERROR,
+                        data: {
+                            ...input.data,
+                            paystackTxId: data.id,
+                            paystackTxData: data,
+                        },
+                    };
+                default:
+                    return {
+                        status: utils_1.PaymentSessionStatus.PENDING,
+                        data: {
+                            ...input.data,
+                            paystackTxId: data.id,
+                            paystackTxData: data,
+                        },
+                    };
+            }
+        }
+        catch (error) {
+            if (this.debug) {
+                this.logger.error("PS_P_Debug: AuthorizePayment: Error", error);
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to authorize payment", error?.toString() ?? "Unknown error");
+        }
+    }
+    async retrievePayment(input) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: RetrievePayment ${JSON.stringify(input, null, 2)}`);
+        }
+        try {
+            const { paystackTxId } = input.data;
+            if (!paystackTxId) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Missing paystackTxId in payment data. This payment has not been authorized.");
+            }
+            const { data, status, message } = await this.paystack.transaction.get({
+                id: paystackTxId,
+            });
+            if (status === false) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to retrieve payment", message);
+            }
+            return {
+                data: {
+                    ...input.data,
+                    paystackTxData: data,
+                },
+            };
+        }
+        catch (error) {
+            if (this.debug) {
+                this.logger.error("PS_P_Debug: RetrievePayment: Error", error);
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to retrieve payment", error?.toString() ?? "Unknown error");
+        }
+    }
+    async refundPayment(input) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: RefundPayment ${JSON.stringify(input, null, 2)}`);
+        }
+        try {
+            const { paystackTxId } = input.data;
+            if (!paystackTxId) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Missing paystackTxId in payment data.");
+            }
+            const { data, status, message } = await this.paystack.refund.create({
+                transaction: paystackTxId,
+                amount: Math.round(Number(input.amount) * 100), // FIX: Subunit conversion
+            });
+            if (status === false) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to refund payment", message);
+            }
+            return {
+                data: {
+                    ...input.data,
+                    paystackTxData: data,
+                },
+            };
+        }
+        catch (error) {
+            if (this.debug) {
+                this.logger.error("PS_P_Debug: RefundPayment: Error", error);
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Failed to refund payment", error?.toString() ?? "Unknown error");
+        }
+    }
+    async getPaymentStatus(input) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: GetPaymentStatus ${JSON.stringify(input, null, 2)}`);
+        }
+        const { paystackTxId } = input.data;
+        if (!paystackTxId) {
+            return { status: utils_1.PaymentSessionStatus.PENDING };
+        }
+        try {
+            const { data, status } = await this.paystack.transaction.get({
+                id: paystackTxId,
+            });
+            if (this.debug) {
+                this.logger.info(`PS_P_Debug: GetPaymentStatus: Verification ${JSON.stringify({ status, data }, null, 2)}`);
+            }
+            if (status === false) {
+                return { status: utils_1.PaymentSessionStatus.ERROR };
+            }
+            switch (data?.status) {
+                case "success":
+                    return { status: utils_1.PaymentSessionStatus.AUTHORIZED };
+                case "failed":
+                    return { status: utils_1.PaymentSessionStatus.ERROR };
+                default:
+                    return { status: utils_1.PaymentSessionStatus.PENDING };
+            }
+        }
+        catch (error) {
+            if (this.debug) {
+                this.logger.error("PS_P_Debug: GetPaymentStatus: Error", error);
+            }
+            return { status: utils_1.PaymentSessionStatus.ERROR };
+        }
+    }
+    async getWebhookActionAndData({ data: { event, data }, rawData, headers, }) {
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: Handling webhook event ${JSON.stringify({ data, headers }, null, 2)}`);
+        }
+        const webhookSecretKey = this.configuration.secret_key;
+        const hash = crypto_1.default
+            .createHmac("sha512", webhookSecretKey)
+            .update(rawData)
+            .digest("hex");
+        if (hash !== headers["x-paystack-signature"]) {
+            return {
+                action: utils_1.PaymentActions.NOT_SUPPORTED,
+            };
+        }
+        if (event !== "charge.success") {
+            return {
+                action: utils_1.PaymentActions.NOT_SUPPORTED,
+            };
+        }
+        const sessionId = data.metadata?.session_id;
+        if (!sessionId) {
+            if (this.debug) {
+                this.logger.error("PS_P_Debug: No sessionId found in webhook transaction metadata");
+            }
+            return {
+                action: utils_1.PaymentActions.NOT_SUPPORTED,
+            };
+        }
+        if (this.debug) {
+            this.logger.info(`PS_P_Debug: Webhook event is valid ${JSON.stringify({ sessionId, amount: data.amount }, null, 2)}`);
+        }
+        return {
+            action: utils_1.PaymentActions.SUCCESSFUL, // FIX: Tell Medusa to capture automatically
+            data: {
+                session_id: sessionId,
+                amount: Number(data.amount) / 100, // FIX: Convert from subunit back to main unit
+            },
+        };
+    }
+    async capturePayment(input) {
+        return { data: input.data };
+    }
+    async cancelPayment(input) {
+        return { data: input.data };
+    }
+    async deletePayment(input) {
+        return { data: input.data };
+    }
+}
+PaystackPaymentProcessor.identifier = "paystack";
+exports.default = PaystackPaymentProcessor;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paystack-payment-processor.js","sourceRoot":"","sources":["../../../../src/services/paystack-payment-processor.ts"],"names":[],"mappings":"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"}