medusa-plugin-braintree 0.1.1

package/.medusa/server/src/admin/index.js

@@ -0,0 +1,22 @@
+"use strict";
+const widgetModule = { widgets: [] };
+const routeModule = {
+  routes: []
+};
+const menuItemModule = {
+  menuItems: []
+};
+const formModule = { customFields: {} };
+const displayModule = {
+  displays: {}
+};
+const i18nModule = { resources: {} };
+const plugin = {
+  widgetModule,
+  routeModule,
+  menuItemModule,
+  formModule,
+  displayModule,
+  i18nModule
+};
+module.exports = plugin;

package/.medusa/server/src/admin/index.mjs

@@ -0,0 +1,23 @@
+const widgetModule = { widgets: [] };
+const routeModule = {
+  routes: []
+};
+const menuItemModule = {
+  menuItems: []
+};
+const formModule = { customFields: {} };
+const displayModule = {
+  displays: {}
+};
+const i18nModule = { resources: {} };
+const plugin = {
+  widgetModule,
+  routeModule,
+  menuItemModule,
+  formModule,
+  displayModule,
+  i18nModule
+};
+export {
+  plugin as default
+};

package/.medusa/server/src/providers/payment-braintree/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const provider_1 = require("./provider");
+exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.PAYMENT, {
+    services: [provider_1.BraintreeProvider]
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3BheW1lbnQtYnJhaW50cmVlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEscURBQW1FO0FBQ25FLHlDQUE4QztBQUU5QyxrQkFBZSxJQUFBLHNCQUFjLEVBQUMsZUFBTyxDQUFDLE9BQU8sRUFBRTtJQUM5QyxRQUFRLEVBQUUsQ0FBQyw0QkFBaUIsQ0FBQztDQUM3QixDQUFDLENBQUEifQ==

package/.medusa/server/src/providers/payment-braintree/provider.js

@@ -0,0 +1,654 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BraintreeProvider = exports.buildBraintreeError = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const braintree_1 = __importDefault(require("braintree"));
+const zod_1 = require("zod");
+const utils_2 = require("./utils");
+const buildTokenCacheKey = (customerId) => `braintree:clientToken:${customerId}`;
+// Type guard utilities for safe type validation
+const validateString = (value, fieldName) => {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, `${fieldName} must be a non-empty string`);
+    }
+    return value;
+};
+// Error handling utility that preserves full error context
+const buildBraintreeError = (error, operation, logger, context) => {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    // Preserve full error context in logging
+    logger.error(`Braintree ${operation} failed: ${errorMessage}`, error instanceof Error ? error : undefined);
+    return new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to ${operation}: ${errorMessage}`);
+};
+exports.buildBraintreeError = buildBraintreeError;
+class BraintreeProvider extends utils_1.AbstractPaymentProvider {
+    constructor(container, options) {
+        super(container, options);
+        this.options_ = options;
+        this.logger = container[utils_1.ContainerRegistrationKeys.LOGGER];
+        this.caching = container[utils_1.Modules.CACHING];
+        this.init();
+    }
+    async saveClientTokenToCache(clientToken, customerId, expiresOnEpochSeconds) {
+        if (!customerId)
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, 'Customer ID is required');
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        const ttlSeconds = expiresOnEpochSeconds - nowSeconds - 1;
+        if (!customerId || !clientToken || ttlSeconds <= 0)
+            return;
+        await this.caching.set({
+            key: buildTokenCacheKey(customerId),
+            data: { token: clientToken },
+            ttl: ttlSeconds
+        });
+    }
+    async getClientTokenFromCache(customerId) {
+        const cached = (await this.caching.get({ key: buildTokenCacheKey(customerId) }));
+        return cached?.token ?? null;
+    }
+    async getValidClientToken(medusaCustomerId, accountHolder) {
+        if (!medusaCustomerId) {
+            const generatedToken = await this.gateway.clientToken.generate({});
+            return generatedToken.clientToken;
+        }
+        const token = await this.getClientTokenFromCache(medusaCustomerId);
+        if (token)
+            return token;
+        const generatedToken = await this.gateway.clientToken.generate({});
+        const defaultExpiryEpochSeconds = Math.floor(Date.now() / 1000) + 24 * 3600; // 24 hours default
+        await this.saveClientTokenToCache(generatedToken.clientToken, medusaCustomerId, defaultExpiryEpochSeconds);
+        return generatedToken.clientToken;
+    }
+    async parsePaymentSessionData(data) {
+        const schema = zod_1.z.object({
+            clientToken: zod_1.z.string().optional(),
+            client_token: zod_1.z.string().optional(),
+            amount: zod_1.z.number().optional(),
+            currency_code: zod_1.z.string().optional(),
+            paymentMethodNonce: zod_1.z.string().optional(),
+            payment_method_nonce: zod_1.z.string().optional(),
+            braintreeTransaction: zod_1.z.any().optional(),
+            transaction: zod_1.z.any().optional(),
+            account_holder: zod_1.z.any().optional(),
+            context: zod_1.z
+                .object({
+                orderId: zod_1.z.string().optional(),
+                customerId: zod_1.z.string().optional(),
+                customer: zod_1.z
+                    .object({
+                    firstName: zod_1.z.string(),
+                    lastName: zod_1.z.string(),
+                    email: zod_1.z.string().email(),
+                    phone: zod_1.z.string().optional()
+                })
+                    .optional(),
+                shipping: zod_1.z
+                    .object({
+                    firstName: zod_1.z.string(),
+                    lastName: zod_1.z.string(),
+                    streetAddress: zod_1.z.string(),
+                    extendedAddress: zod_1.z.string().optional(),
+                    locality: zod_1.z.string(),
+                    region: zod_1.z.string(),
+                    postalCode: zod_1.z.string(),
+                    countryCodeAlpha2: zod_1.z.string()
+                })
+                    .optional(),
+                billing: zod_1.z
+                    .object({
+                    firstName: zod_1.z.string(),
+                    lastName: zod_1.z.string(),
+                    streetAddress: zod_1.z.string(),
+                    extendedAddress: zod_1.z.string().optional(),
+                    locality: zod_1.z.string(),
+                    region: zod_1.z.string(),
+                    postalCode: zod_1.z.string(),
+                    countryCodeAlpha2: zod_1.z.string()
+                })
+                    .optional(),
+                deviceData: zod_1.z.string().optional(),
+                customFields: zod_1.z.any().optional()
+            })
+                .optional()
+        });
+        const result = schema.safeParse(data);
+        if (!result.success) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, result.error.message);
+        }
+        result.data.transaction = result.data.transaction ?? result.data.braintreeTransaction;
+        result.data.client_token = result.data.client_token ?? result.data.clientToken;
+        result.data.payment_method_nonce =
+            result.data.payment_method_nonce ?? result.data.paymentMethodNonce;
+        return result.data;
+    }
+    init() {
+        const envKey = (this.options_.environment || 'sandbox').toLowerCase();
+        const envMap = {
+            qa: braintree_1.default.Environment.Qa,
+            sandbox: braintree_1.default.Environment.Sandbox,
+            production: braintree_1.default.Environment.Production,
+            development: braintree_1.default.Environment.Development
+        };
+        const environment = envMap[envKey] ?? braintree_1.default.Environment.Sandbox;
+        this.gateway =
+            this.gateway ||
+                new braintree_1.default.BraintreeGateway({
+                    environment,
+                    merchantId: this.options_.merchantId,
+                    publicKey: this.options_.publicKey,
+                    privateKey: this.options_.privateKey
+                });
+    }
+    static validateOptions(options) {
+        const requiredStringFields = [
+            'merchantId',
+            'publicKey',
+            'privateKey',
+            'webhookSecret',
+            'environment'
+        ];
+        for (const field of requiredStringFields) {
+            if (!(0, utils_1.isDefined)(options[field]) || typeof options[field] !== 'string') {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, `Required option "${field}" is missing or invalid in Braintree plugin`);
+            }
+        }
+        const validEnvironments = ['qa', 'sandbox', 'production', 'development'];
+        if (!validEnvironments.includes(options.environment.toLowerCase())) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, `Invalid environment "${options.environment}" in Braintree plugin. Must be one of: ${validEnvironments.join(', ')}`);
+        }
+        options.enable3DSecure = options.enable3DSecure ?? false;
+        options.savePaymentMethod = options.savePaymentMethod ?? false;
+        options.autoCapture = options.autoCapture ?? false;
+        options.allowRefundOnRefunded = options.allowRefundOnRefunded ?? false;
+        const booleanFields = [
+            'enable3DSecure',
+            'savePaymentMethod',
+            'autoCapture',
+            'allowRefundOnRefunded'
+        ];
+        for (const field of booleanFields) {
+            if ((0, utils_1.isDefined)(options[field]) && typeof options[field] !== 'boolean') {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, `Option "${field}" must be a boolean in Braintree plugin`);
+            }
+        }
+    }
+    async capturePayment(input) {
+        const sessionData = await this.parsePaymentSessionData(input.data ?? {});
+        const transaction = sessionData.transaction;
+        if (!transaction) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, 'Braintree transaction not found');
+        }
+        const paymentsResponse = await this.gateway.transaction.find(transaction.id);
+        switch (paymentsResponse.status) {
+            case 'authorized': {
+                const { id, amount } = paymentsResponse;
+                const toPay = amount.toString();
+                const captureResult = await this.gateway.transaction.submitForSettlement(id, toPay);
+                if (captureResult.success) {
+                    const _transaction = await this.retrieveTransaction(transaction.id);
+                    return {
+                        data: {
+                            ...input.data,
+                            transaction: _transaction
+                        }
+                    };
+                }
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `No payments found for transaction ${transaction.id}`);
+            }
+            case 'settled':
+            case 'settling':
+            case 'submitted_for_settlement': {
+                const _transaction = await this.retrieveTransaction(transaction.id);
+                return {
+                    data: {
+                        ...input.data,
+                        transaction: _transaction
+                    }
+                };
+            }
+            default: {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Not in a state to settle ${transaction.id}`);
+            }
+        }
+    }
+    async authorizePayment(input) {
+        try {
+            const sessionData = await this.parsePaymentSessionData(input.data ?? {});
+            let transaction = sessionData.transaction;
+            if (!sessionData.payment_method_nonce)
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, 'Payment method nonce is required');
+            if (!transaction) {
+                transaction = await this.createTransaction({
+                    input
+                });
+            }
+            const paymentStatusRequest = {
+                ...input,
+                data: {
+                    ...input.data,
+                    transaction
+                }
+            };
+            const status = await this.getPaymentStatus(paymentStatusRequest);
+            const finalStatus = status.status === 'authorized' && this.options_.autoCapture ? 'captured' : status.status;
+            return {
+                data: {
+                    ...input.data,
+                    transaction
+                },
+                status: finalStatus
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            this.logger.error(`Error authorizing transaction: ${message}`, error instanceof Error ? error : undefined);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, message);
+        }
+    }
+    async cancelPayment(input) {
+        const sessionData = await this.parsePaymentSessionData(input.data ?? {});
+        const transaction = await this.retrieveTransaction(sessionData.transaction?.id);
+        if (!transaction)
+            return {};
+        if (transaction.status === 'authorized' ||
+            transaction.status === 'submitted_for_settlement' ||
+            (transaction.status === 'settling' &&
+                transaction.paymentInstrumentType === 'paypal_account')) {
+            const updatedTransaction = await this.gateway.transaction.void(transaction.id);
+            if (updatedTransaction) {
+                const updated = await this.retrieveTransaction(transaction.id);
+                return {
+                    data: {
+                        ...input.data,
+                        transaction: updated
+                    }
+                };
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `No payments found for transaction ${transaction.id}`);
+        }
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Payment cannot be cancelled ${transaction.id}`);
+    }
+    async retrieveTransaction(id, throwOnMissing = true) {
+        const transactionData = await this.gateway.transaction.find(id);
+        if (!transactionData && throwOnMissing)
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Braintree transaction not found: ${id}`);
+        return transactionData;
+    }
+    mapTransactionStatusToPaymentStatus(status) {
+        switch (status) {
+            case 'authorization_expired':
+                return utils_1.PaymentSessionStatus.CANCELED;
+            case 'authorizing':
+                return utils_1.PaymentSessionStatus.REQUIRES_MORE;
+            case 'authorized':
+                return utils_1.PaymentSessionStatus.AUTHORIZED;
+            case 'settled':
+            case 'settlement_confirmed':
+                return utils_1.PaymentSessionStatus.CAPTURED;
+            case 'settling':
+            case 'settlement_pending':
+            case 'submitted_for_settlement':
+                return utils_1.PaymentSessionStatus.AUTHORIZED;
+            case 'voided':
+                return utils_1.PaymentSessionStatus.CANCELED;
+            case 'failed':
+                return utils_1.PaymentSessionStatus.ERROR;
+            default:
+                return utils_1.PaymentSessionStatus.PENDING;
+        }
+    }
+    validateInitiatePaymentData(data) {
+        const schema = zod_1.z.object({
+            paymentMethodNonce: zod_1.z.string().optional(),
+            payment_method_nonce: zod_1.z.string().optional(),
+            cardDetails: zod_1.z
+                .object({
+                cardType: zod_1.z.string().optional(),
+                lastFour: zod_1.z.string().optional(),
+                lastTwo: zod_1.z.string().optional(),
+                expirationMonth: zod_1.z.string().optional(),
+                expirationYear: zod_1.z.string().optional(),
+                cardholderName: zod_1.z.string().optional()
+            })
+                .optional()
+        });
+        const result = schema.safeParse(data);
+        if (!result.success) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, result.error.message);
+        }
+        result.data.payment_method_nonce =
+            result.data.payment_method_nonce ?? result.data.paymentMethodNonce;
+        return result.data;
+    }
+    async initiatePayment(input) {
+        const data = this.validateInitiatePaymentData(input.data ?? {});
+        let transaction;
+        const token = await this.getValidClientToken(input.context?.customer?.id, input.context?.account_holder);
+        const paymentSessionId = validateString(input.context?.idempotency_key, 'Payment session ID');
+        if (!token) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, 'Failed to generate client token');
+        }
+        const dataToSave = {
+            transaction: transaction,
+            client_token: token,
+            payment_method_nonce: data?.payment_method_nonce,
+            amount: Number(input.amount),
+            currency_code: input.currency_code,
+            account_holder: input.context?.account_holder
+        };
+        return {
+            id: paymentSessionId,
+            data: { ...dataToSave }
+        };
+    }
+    async createTransaction({ input }) {
+        const sessionData = await this.parsePaymentSessionData(input.data ?? {});
+        const { context } = sessionData;
+        let transactionRequest = {
+            amount: (0, utils_2.formatToTwoDecimalString)(Number(sessionData.amount)),
+            paymentMethodNonce: validateString(sessionData.payment_method_nonce, 'Payment method nonce'),
+            options: {
+                submitForSettlement: this.options_.autoCapture,
+                storeInVaultOnSuccess: this.options_.savePaymentMethod,
+                storeInVault: this.options_.savePaymentMethod,
+                threeDSecure: this.options_.enable3DSecure
+                    ? {
+                        required: this.options_.enable3DSecure
+                    }
+                    : undefined
+            }
+        };
+        if (context?.orderId)
+            transactionRequest.orderId = context.orderId;
+        if (context?.customer)
+            transactionRequest.customer = context.customer;
+        if (context?.shipping)
+            transactionRequest.shipping = context.shipping;
+        if (context?.billing)
+            transactionRequest.billing = context.billing;
+        if (context?.deviceData)
+            transactionRequest.deviceData = context.deviceData;
+        if (context?.customFields)
+            transactionRequest.customFields = context.customFields;
+        try {
+            const saleResponse = await this.gateway.transaction.sale(transactionRequest);
+            if (!saleResponse.success) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, saleResponse.transaction?.gatewayRejectionReason ?? 'Unknown error');
+            }
+            try {
+                return await this.retrieveTransaction(saleResponse.transaction.id);
+            }
+            catch (error) {
+                if (saleResponse.transaction?.id) {
+                    await this.gateway.transaction.void(saleResponse.transaction.id);
+                }
+                throw (0, exports.buildBraintreeError)(error, 'sync payment session', this.logger, {
+                    transactionId: saleResponse.transaction?.id
+                });
+            }
+        }
+        catch (error) {
+            throw (0, exports.buildBraintreeError)(error, 'create Braintree transaction', this.logger);
+        }
+    }
+    async deletePayment(input) {
+        const sessionData = await this.parsePaymentSessionData(input.data ?? {});
+        const transaction = sessionData.transaction;
+        if (transaction) {
+            try {
+                const result = await this.cancelPayment(input);
+                return {
+                    data: {
+                        ...input.data,
+                        transaction: result.data?.transaction
+                    }
+                };
+            }
+            catch (e) {
+                throw (0, exports.buildBraintreeError)(e, 'delete Braintree payment', this.logger);
+            }
+        }
+        else {
+            return {
+                data: {
+                    ...input.data,
+                    transaction
+                }
+            };
+        }
+    }
+    async getPaymentStatus(input) {
+        // Support both `data.transaction` and `data.braintreeTransaction` without requiring full session parsing
+        const tx = (input.data?.transaction ?? input.data?.braintreeTransaction);
+        const id = tx?.id;
+        if (!id) {
+            return { status: utils_1.PaymentSessionStatus.PENDING };
+        }
+        let transaction;
+        try {
+            transaction = await this.gateway.transaction.find(id);
+        }
+        catch (e) {
+            this.logger.warn('received payment data from session not transaction data');
+            throw e;
+        }
+        const status = this.mapTransactionStatusToPaymentStatus(transaction.status);
+        return { status };
+    }
+    async savePaymentMethod(input) {
+        const sessionData = await this.parsePaymentSessionData(input.data ?? {});
+        const braintreeCustomerId = validateString(input.context?.account_holder?.data?.id, 'Braintree customer ID');
+        const paymentMethodNonce = sessionData?.payment_method_nonce;
+        if (!paymentMethodNonce) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, 'Payment method nonce is required');
+        }
+        const paymentMethodResult = await this.gateway.paymentMethod.create({
+            customerId: braintreeCustomerId,
+            paymentMethodNonce: paymentMethodNonce
+        });
+        if (!paymentMethodResult.success) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to save payment method: ${JSON.stringify(paymentMethodResult.errors)}`);
+        }
+        return {
+            id: paymentMethodResult.paymentMethod.token,
+            data: {
+                ...input.data
+            }
+        };
+    }
+    async refundPayment(input) {
+        const sessionData = await this.parsePaymentSessionData(input.data ?? {});
+        const refundAmountBN = utils_1.MathBN.convert(input.amount, 2);
+        const refundAmount = refundAmountBN.toNumber();
+        if (!refundAmount)
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, 'Refund amount is invalid');
+        let transaction = await this.retrieveTransaction(sessionData.transaction?.id);
+        let shouldVoid = ['submitted_for_settlement', 'authorized'].includes(transaction.status);
+        if (process.env.TEST_FORCE_SETTLED === 'true') {
+            shouldVoid = false;
+            await this.gateway.testing.settle(transaction.id);
+            transaction = await this.retrieveTransaction(transaction.id);
+        }
+        if (shouldVoid) {
+            const voidResponse = await this.gateway.transaction.void(transaction.id);
+            const voidSucceeded = voidResponse.success ?? false;
+            if (!voidSucceeded)
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, 'Failed to void transaction');
+            const voidedTransaction = voidResponse?.transaction ?? (await this.retrieveTransaction(transaction.id));
+            const refundResult = {
+                data: {
+                    ...input.data,
+                    transaction: voidedTransaction,
+                    braintreeRefund: {
+                        success: true,
+                        transactionId: voidedTransaction?.id,
+                        type: 'void'
+                    }
+                }
+            };
+            return refundResult;
+        }
+        const shouldRefund = ['settled', 'settling'].includes(transaction.status);
+        if (!shouldRefund) {
+            this.logger.error(`Braintree transaction with ID ${transaction.id} cannot be refunded because it's in status ${transaction.status}`);
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Braintree transaction with ID ${transaction.id} cannot be refunded`);
+        }
+        if (transaction.id) {
+            const refundAmountDecimal = (0, utils_2.formatToTwoDecimalString)(refundAmount);
+            try {
+                this.logger.info(`Refunding transaction: ${transaction.id} with amount: ${refundAmountDecimal} (created from ${refundAmount})`);
+                const refundResponse = await this.gateway.transaction.refund(transaction.id, refundAmountDecimal);
+                const refundSucceeded = refundResponse.success ?? false;
+                if (!refundSucceeded)
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to create Braintree refund: ${refundResponse.message}`);
+                const refundTransaction = refundResponse.transaction ?? (await this.retrieveTransaction(transaction.id));
+                const refundResult = {
+                    data: {
+                        ...input.data,
+                        transaction: refundTransaction,
+                        braintreeRefund: refundTransaction
+                    }
+                };
+                return refundResult;
+            }
+            catch (e) {
+                throw (0, exports.buildBraintreeError)(e, 'create Braintree refund', this.logger);
+            }
+        }
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Braintree transaction with ID ${transaction.id} not found`);
+    }
+    async retrievePayment(input) {
+        const paymentSessionData = await this.parsePaymentSessionData(input.data ?? {});
+        if (!paymentSessionData.transaction?.id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, 'Braintree transaction not found');
+        }
+        const retrieved = await this.retrieveTransaction(paymentSessionData.transaction?.id);
+        return {
+            data: {
+                ...input.data,
+                transaction: retrieved
+            }
+        };
+    }
+    async updatePayment(input) {
+        return Promise.resolve({
+            data: {
+                ...input.data,
+                amount: input.amount,
+                currency_code: input.currency_code
+            }
+        });
+    }
+    async createAccountHolder(input) {
+        const customer = await this.createBraintreeCustomer(input.context.customer);
+        return {
+            id: customer.id,
+            data: {
+                ...customer
+            }
+        };
+    }
+    async updateAccountHolder(input) {
+        const { context } = input;
+        const accountHolderId = context.account_holder?.data?.id;
+        if (!accountHolderId) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Account holder id is required`);
+        }
+        try {
+            const accountHolder = await this.gateway.customer.find(accountHolderId);
+            if (!accountHolder) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Account holder with id ${accountHolderId} not found`);
+            }
+            const customerUpdateRequest = {
+                firstName: input.context.customer?.first_name ?? accountHolder.firstName,
+                lastName: input.context.customer?.last_name ?? accountHolder.lastName,
+                email: input.context.customer?.email ?? accountHolder.email,
+                phone: input.context.customer?.phone ?? accountHolder.phone
+            };
+            const updateResult = await this.gateway.customer.update(accountHolder.id, customerUpdateRequest);
+            if (!updateResult.success) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to update account holder: ${JSON.stringify(updateResult.errors)}`);
+            }
+            return {
+                data: { ...updateResult.customer }
+            };
+        }
+        catch (e) {
+            throw (0, exports.buildBraintreeError)(e, 'update account holder', this.logger);
+        }
+    }
+    async deleteAccountHolder(input) {
+        const { context } = input;
+        const accountHolderId = context.account_holder?.data?.id;
+        if (!accountHolderId)
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Account holder id is required`);
+        try {
+            const accountHolder = await this.gateway.customer.find(accountHolderId);
+            if (!accountHolder)
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Account holder with id ${accountHolderId} not found`);
+            await this.gateway.customer.delete(accountHolder.id);
+            return {
+                data: {}
+            };
+        }
+        catch (e) {
+            throw (0, exports.buildBraintreeError)(e, 'delete account holder', this.logger);
+        }
+    }
+    async getWebhookActionAndData(webhookData) {
+        const logger = this.logger;
+        logger.info(`Received Braintree webhook with data: ${!!webhookData.data}`);
+        const decodedPayload = new URLSearchParams(webhookData.data);
+        let notification;
+        try {
+            notification = (await this.gateway.webhookNotification.parse(decodedPayload.get('bt_signature') ?? '', decodedPayload.get('bt_payload') ?? ''));
+            if (!notification) {
+                return { action: utils_1.PaymentActions.FAILED };
+            }
+        }
+        catch (error) {
+            logger.error(`Braintree webhook validation failed : ${error}`);
+            return { action: utils_1.PaymentActions.FAILED };
+        }
+        const paymentData = await this.gateway.transaction.find(notification.transaction.id);
+        const customFields = paymentData.customFields;
+        switch (notification.kind) {
+            case 'transaction_settled':
+                return {
+                    action: utils_1.PaymentActions.SUCCESSFUL,
+                    data: {
+                        session_id: customFields.medusa_payment_session_id ?? '',
+                        amount: paymentData.amount
+                    }
+                };
+            case 'transaction_settlement_declined':
+                return {
+                    action: utils_1.PaymentActions.FAILED,
+                    data: {
+                        session_id: customFields.medusa_payment_session_id ?? '',
+                        amount: paymentData.amount
+                    }
+                };
+            default:
+                return { action: utils_1.PaymentActions.NOT_SUPPORTED };
+        }
+    }
+    async createBraintreeCustomer(customer) {
+        const customerResult = await this.gateway.customer.create({
+            email: customer.email,
+            firstName: customer.first_name ?? undefined,
+            lastName: customer.last_name ?? undefined,
+            phone: customer.phone ?? undefined
+        });
+        if (!customerResult.success) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Failed to create Braintree customer: ${JSON.stringify(customerResult.errors)}`);
+        }
+        return customerResult.customer;
+    }
+}
+exports.BraintreeProvider = BraintreeProvider;
+BraintreeProvider.identifier = 'braintree';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provider.js","sourceRoot":"","sources":["../../../../../src/providers/payment-braintree/provider.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/providers/payment-braintree/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3BheW1lbnQtYnJhaW50cmVlL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/.medusa/server/src/providers/payment-braintree/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatToTwoDecimalString = formatToTwoDecimalString;
+const utils_1 = require("@medusajs/framework/utils");
+/**
+ * Formats a number or string to a two-decimal string representation.
+ * Validates the input is parseable to a number and throws MedusaError on NaN.
+ *
+ * @param amount - The amount to format (number or string)
+ * @returns A string representation with exactly 2 decimal places
+ * @throws MedusaError if the amount is not a valid number
+ */
+function formatToTwoDecimalString(amount) {
+    if (typeof amount !== 'string') {
+        amount = amount.toString();
+    }
+    const num = Number.parseFloat(amount);
+    if (Number.isNaN(num)) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_ARGUMENT, 'Invalid amount');
+    }
+    return num.toFixed(2);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3BheW1lbnQtYnJhaW50cmVlL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBVUEsNERBWUM7QUF0QkQscURBQXVEO0FBRXZEOzs7Ozs7O0dBT0c7QUFDSCxTQUFnQix3QkFBd0IsQ0FBQyxNQUF1QjtJQUMvRCxJQUFJLE9BQU8sTUFBTSxLQUFLLFFBQVEsRUFBRSxDQUFDO1FBQ2hDLE1BQU0sR0FBRyxNQUFNLENBQUMsUUFBUSxFQUFFLENBQUE7SUFDM0IsQ0FBQztJQUVELE1BQU0sR0FBRyxHQUFHLE1BQU0sQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUE7SUFFckMsSUFBSSxNQUFNLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7UUFDdkIsTUFBTSxJQUFJLG1CQUFXLENBQUMsbUJBQVcsQ0FBQyxLQUFLLENBQUMsZ0JBQWdCLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQTtJQUM1RSxDQUFDO0lBRUQsT0FBTyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxDQUFBO0FBQ3RCLENBQUMifQ==

package/package.json

@@ -0,0 +1,77 @@
+{
+	"name": "medusa-plugin-braintree",
+	"version": "0.1.1",
+	"description": "Braintree payment provider plugin for Medusa v2",
+	"author": "Lacey Pevey",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/pevey/medusa-plugins"
+	},
+	"homepage": "https://pevey.com/medusa-plugin-braintree",
+	"files": [
+		".medusa/server"
+	],
+	"exports": {
+		"./package.json": "./package.json",
+		"./.medusa/server/src/modules/*": "./.medusa/server/src/modules/*/index.js",
+		"./modules/*": "./.medusa/server/src/modules/*/index.js",
+		"./providers/*": "./.medusa/server/src/providers/*/index.js",
+		"./*": "./.medusa/server/src/*.js",
+		".": "./.medusa/server/src/providers/payment-braintree/index.js"
+	},
+	"keywords": [
+		"medusa-plugin-payment",
+		"medusa-v2",
+		"medusa",
+		"medusa-plugin-braintree",
+		"braintree",
+		"payment"
+	],
+	"scripts": {
+		"build": "medusa plugin:build",
+		"dev": "medusa plugin:develop",
+		"prepublishOnly": "medusa plugin:build",
+		"test:unit": "TEST_TYPE=unit NODE_OPTIONS=--experimental-vm-modules jest --silent --runInBand --detectOpenHandles --forceExit"
+	},
+	"dependencies": {
+		"braintree": "3.36.0"
+	},
+	"devDependencies": {
+		"@medusajs/admin-sdk": "2.13.6",
+		"@medusajs/cli": "2.13.6",
+		"@medusajs/framework": "2.13.6",
+		"@medusajs/icons": "2.13.6",
+		"@medusajs/medusa": "2.13.6",
+		"@medusajs/test-utils": "2.13.6",
+		"@medusajs/ui": "4.0.25",
+		"@swc/core": "^1.7.28",
+		"@swc/jest": "^0.2.39",
+		"@types/braintree": "3.4.4",
+		"@types/jest": "^30.0.0",
+		"@types/node": "^20.0.0",
+		"@types/react": "^18.3.2",
+		"@types/react-dom": "^18.2.25",
+		"jest": "^29.7.0",
+		"prop-types": "^15.8.1",
+		"react": "^18.2.0",
+		"react-dom": "^18.2.0",
+		"ts-node": "^10.9.2",
+		"typescript": "^5.6.2",
+		"vite": "^5.2.11",
+		"yalc": "^1.0.0-pre.53"
+	},
+	"peerDependencies": {
+		"@medusajs/admin-sdk": "2.13.6",
+		"@medusajs/cli": "2.13.6",
+		"@medusajs/framework": "2.13.6",
+		"@medusajs/icons": "2.13.6",
+		"@medusajs/medusa": "2.13.6",
+		"@medusajs/test-utils": "2.13.6",
+		"@medusajs/ui": "4.0.25"
+	},
+	"engines": {
+		"node": ">=20"
+	},
+	"packageManager": "yarn@4.13.0+sha512.5c20ba010c99815433e5c8453112165e673f1c7948d8d2b267f4b5e52097538658388ebc9f9580656d9b75c5cc996f990f611f99304a2197d4c56d21eea370e7"
+}