@enomshop/paystack 0.0.1

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: "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,95 @@
+"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.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/services/paystack-payment-processor.js

@@ -0,0 +1,284 @@
+"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);
+        // Paystack Supported Currencies
+        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");
+        }
+        try {
+            const { data: psData, status, message, } = await this.paystack.transaction.initialize({
+                amount: Math.round(Number(amount)), // FIXED: Medusa amounts are already in lowest denomination
+                email,
+                currency: validatedCurrencyCode,
+                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 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, // MEDUSA V2 COMPLIANT
+                        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)), // FIXED: Medusa amounts are already in lowest denomination
+            });
+            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.AUTHORIZED,
+            data: {
+                session_id: sessionId,
+                amount: data.amount,
+            },
+        };
+    }
+    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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"}

package/.medusa/server/src/utils/currencyCode.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCurrencyCode = formatCurrencyCode;
+function formatCurrencyCode(currencyCode) {
+    // Uppercase the currency code
+    const formattedCurrencyCode = currencyCode.toUpperCase();
+    return formattedCurrencyCode;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VycmVuY3lDb2RlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3V0aWxzL2N1cnJlbmN5Q29kZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLGdEQUtDO0FBTEQsU0FBZ0Isa0JBQWtCLENBQUMsWUFBb0I7SUFDckQsOEJBQThCO0lBQzlCLE1BQU0scUJBQXFCLEdBQUcsWUFBWSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBRXpELE9BQU8scUJBQXFCLENBQUM7QUFDL0IsQ0FBQyJ9