@thorprovider/adapters 3.0.2

package/src/providers/medusa/medusa.ts

@@ -0,0 +1,8 @@
+/**
+ * @thorprovider/adapters v2.0
+ * Medusa Provider exports
+ */
+
+export { MedusaProvider } from './index';
+export type { MedusaProviderConfig } from './index';
+export * from './transforms';

package/src/providers/medusa/payment.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * @thorprovider/adapters v2.0
+ * Medusa Payment Provider Implementation
+ *
+ * Transforms Medusa payment providers to Thor's unified PaymentMethod format.
+ * Handles region-specific payment provider queries.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPaymentMethod = transformPaymentMethod;
+exports.getPaymentMethods = getPaymentMethods;
+var errors_1 = require("../../core/errors");
+/**
+ * Map of Medusa provider names to display names
+ */
+var PROVIDER_DISPLAY_NAMES = {
+    stripe: 'Stripe',
+    paypal: 'PayPal',
+    system: 'Cash on Delivery',
+    manual: 'Manual Payment',
+    bancontact: 'Bancontact',
+    blik: 'BLIK',
+    giropay: 'giropay',
+    ideal: 'iDEAL',
+    przelewy24: 'Przelewy24',
+    promptpay: 'PromptPay',
+    oxxo: 'OXXO',
+};
+/**
+ * Infer payment method type from Medusa provider ID
+ *
+ * Medusa format: pp_{provider}_{method}
+ * Examples:
+ * - pp_stripe_stripe → 'card'
+ * - pp_paypal_paypal → 'wallet'
+ * - pp_system_default → 'cash_on_delivery'
+ * - pp_stripe_bancontact → 'bank_transfer'
+ *
+ * @param providerId - Medusa provider ID
+ * @returns Normalized payment method type
+ */
+function inferPaymentType(providerId) {
+    var id = providerId.toLowerCase();
+    // Card payments
+    if (id.includes('stripe') || id.includes('card')) {
+        return 'card';
+    }
+    // Digital wallets
+    if (id.includes('paypal') ||
+        id.includes('wallet') ||
+        id.includes('apple') ||
+        id.includes('google')) {
+        return 'wallet';
+    }
+    // Bank transfers
+    if (id.includes('bancontact') ||
+        id.includes('ideal') ||
+        id.includes('giropay') ||
+        id.includes('sepa') ||
+        id.includes('ach') ||
+        id.includes('bank')) {
+        return 'bank_transfer';
+    }
+    // Buy now pay later
+    if (id.includes('klarna') ||
+        id.includes('affirm') ||
+        id.includes('afterpay') ||
+        id.includes('przelewy24')) {
+        return 'buy_now_pay_later';
+    }
+    // Cash on delivery / Manual
+    if (id.includes('system') ||
+        id.includes('manual') ||
+        id.includes('cod') ||
+        id.includes('default')) {
+        return 'cash_on_delivery';
+    }
+    // Crypto
+    if (id.includes('crypto') || id.includes('bitcoin')) {
+        return 'crypto';
+    }
+    return 'other';
+}
+/**
+ * Parse Medusa provider ID to extract provider and method names
+ *
+ * @param providerId - Medusa provider ID (e.g., "pp_stripe_stripe")
+ * @returns Object with provider and method names
+ */
+function parseProviderId(providerId) {
+    // Medusa format: pp_{provider}_{method}
+    var match = providerId.match(/^pp_([^_]+)_(.+)$/);
+    if (match) {
+        return {
+            provider: match[1],
+            method: match[2],
+        };
+    }
+    // Fallback for non-standard formats
+    return {
+        provider: 'unknown',
+        method: providerId,
+    };
+}
+/**
+ * Get display name for a provider
+ */
+function getDisplayName(providerName) {
+    return PROVIDER_DISPLAY_NAMES[providerName.toLowerCase()] ||
+        providerName.charAt(0).toUpperCase() + providerName.slice(1);
+}
+/**
+ * Transform Medusa payment provider to Thor payment method
+ *
+ * @param medusaProvider - Medusa payment provider from API
+ * @returns Normalized Thor PaymentMethod
+ */
+function transformPaymentMethod(medusaProvider) {
+    var providerId = medusaProvider.id;
+    var _a = parseProviderId(providerId), provider = _a.provider, method = _a.method;
+    var type = inferPaymentType(providerId);
+    // Determine features based on provider type
+    var isStripe = provider === 'stripe';
+    var isSystemDefault = provider === 'system' || method === 'default';
+    var isPayPal = provider === 'paypal';
+    return {
+        id: providerId,
+        name: getDisplayName(provider),
+        type: type,
+        isEnabled: true, // Medusa returns only enabled providers by default
+        requiresSetup: !isSystemDefault, // System/manual payment requires no setup
+        metadata: {
+            providerId: provider,
+            methodId: method,
+            originalData: medusaProvider,
+            _backendMapping: {
+                backend: 'medusa',
+                originalId: providerId,
+                normalizedType: type,
+            },
+        },
+        features: {
+            // Stripe supports saving payment methods
+            saveForLater: isStripe,
+            // Stripe requires 3DS for SCA compliance
+            requires3DS: isStripe,
+            // Most providers support refunds except COD/manual
+            supportsRefunds: !isSystemDefault,
+            // Stripe has minimum amounts (varies by currency)
+            minAmount: isStripe ? 50 : undefined, // 50 cents minimum for Stripe
+            // PayPal has maximum transaction limits
+            maxAmount: isPayPal ? 1000000 : undefined, // $10,000 for PayPal
+        },
+    };
+}
+/**
+ * Get payment methods for Medusa
+ *
+ * Queries Medusa API for available payment providers in a region.
+ * Medusa requires either regionId or cartId to determine available providers.
+ *
+ * @param sdk - Medusa SDK instance
+ * @param options - Payment methods query options
+ * @returns Array of normalized payment methods
+ *
+ * @throws {Error} If neither regionId nor cartId is provided
+ * @throws {ProviderAPIError} If API request fails
+ */
+function getPaymentMethods(sdk, options) {
+    return __awaiter(this, void 0, void 0, function () {
+        var regionId, cart, error_1, err, response, methods, error_2, err;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    regionId = options.regionId;
+                    if (!(options.cartId && !regionId)) return [3 /*break*/, 4];
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, sdk.store.cart.retrieve(options.cartId)];
+                case 2:
+                    cart = (_a.sent()).cart;
+                    regionId = cart.region_id;
+                    return [3 /*break*/, 4];
+                case 3:
+                    error_1 = _a.sent();
+                    err = error_1;
+                    throw new errors_1.ProviderAPIError('Failed to fetch cart to determine region', 'medusa', err === null || err === void 0 ? void 0 : err.status);
+                case 4:
+                    // Validate that we have a region ID
+                    if (!regionId) {
+                        throw new Error('Either regionId or cartId is required for Medusa payment methods. ' +
+                            'Medusa requires a region to determine available payment providers.');
+                    }
+                    _a.label = 5;
+                case 5:
+                    _a.trys.push([5, 7, , 8]);
+                    return [4 /*yield*/, sdk.store.payment.listPaymentProviders({
+                            region_id: regionId,
+                        })];
+                case 6:
+                    response = _a.sent();
+                    methods = response.payment_providers.map(transformPaymentMethod);
+                    // Apply filters
+                    if (options.enabledOnly !== false) { // Default to true
+                        methods = methods.filter(function (m) { return m.isEnabled; });
+                    }
+                    // Filter by currency if provided
+                    if (options.currencyCode) {
+                        methods = methods.filter(function (m) {
+                            var _a;
+                            // If method specifies supported currencies, check them
+                            if ((_a = m.features) === null || _a === void 0 ? void 0 : _a.supportedCurrencies) {
+                                return m.features.supportedCurrencies.includes(options.currencyCode);
+                            }
+                            // Otherwise assume all currencies supported
+                            return true;
+                        });
+                    }
+                    return [2 /*return*/, methods];
+                case 7:
+                    error_2 = _a.sent();
+                    err = error_2;
+                    throw new errors_1.ProviderAPIError('Failed to fetch payment providers from Medusa', 'medusa', err === null || err === void 0 ? void 0 : err.status);
+                case 8: return [2 /*return*/];
+            }
+        });
+    });
+}

package/src/providers/medusa/payment.ts

@@ -0,0 +1,269 @@
+/**
+ * @thorprovider/adapters v2.0
+ * Medusa Payment Provider Implementation
+ * 
+ * Transforms Medusa payment providers to Thor's unified PaymentMethod format.
+ * Handles region-specific payment provider queries.
+ */
+
+import type Medusa from '@medusajs/js-sdk';
+import type { HttpTypes } from '@medusajs/types';
+import type { 
+  PaymentMethod, 
+  PaymentMethodsOptions, 
+  PaymentMethodType 
+} from '@thorprovider/types';
+import { ProviderAPIError } from '../../core/errors';
+
+/**
+ * Map of Medusa provider names to display names
+ */
+const PROVIDER_DISPLAY_NAMES: Record<string, string> = {
+  stripe: 'Stripe',
+  paypal: 'PayPal',
+  system: 'Cash on Delivery',
+  manual: 'Manual Payment',
+  bancontact: 'Bancontact',
+  blik: 'BLIK',
+  giropay: 'giropay',
+  ideal: 'iDEAL',
+  przelewy24: 'Przelewy24',
+  promptpay: 'PromptPay',
+  oxxo: 'OXXO',
+};
+
+/**
+ * Infer payment method type from Medusa provider ID
+ * 
+ * Medusa format: pp_{provider}_{method}
+ * Examples:
+ * - pp_stripe_stripe → 'card'
+ * - pp_paypal_paypal → 'wallet'
+ * - pp_system_default → 'cash_on_delivery'
+ * - pp_stripe_bancontact → 'bank_transfer'
+ * 
+ * @param providerId - Medusa provider ID
+ * @returns Normalized payment method type
+ */
+function inferPaymentType(providerId: string): PaymentMethodType {
+  const id = providerId.toLowerCase();
+  
+  // Card payments
+  if (id.includes('stripe') || id.includes('card')) {
+    return 'card';
+  }
+  
+  // Digital wallets
+  if (
+    id.includes('paypal') || 
+    id.includes('wallet') ||
+    id.includes('apple') ||
+    id.includes('google')
+  ) {
+    return 'wallet';
+  }
+  
+  // Bank transfers
+  if (
+    id.includes('bancontact') ||
+    id.includes('ideal') ||
+    id.includes('giropay') ||
+    id.includes('sepa') ||
+    id.includes('ach') ||
+    id.includes('bank')
+  ) {
+    return 'bank_transfer';
+  }
+  
+  // Buy now pay later
+  if (
+    id.includes('klarna') ||
+    id.includes('affirm') ||
+    id.includes('afterpay') ||
+    id.includes('przelewy24')
+  ) {
+    return 'buy_now_pay_later';
+  }
+  
+  // Cash on delivery / Manual
+  if (
+    id.includes('system') ||
+    id.includes('manual') ||
+    id.includes('cod') ||
+    id.includes('default')
+  ) {
+    return 'cash_on_delivery';
+  }
+  
+  // Crypto
+  if (id.includes('crypto') || id.includes('bitcoin')) {
+    return 'crypto';
+  }
+  
+  return 'other';
+}
+
+/**
+ * Parse Medusa provider ID to extract provider and method names
+ * 
+ * @param providerId - Medusa provider ID (e.g., "pp_stripe_stripe")
+ * @returns Object with provider and method names
+ */
+function parseProviderId(providerId: string): { provider: string; method: string } {
+  // Medusa format: pp_{provider}_{method}
+  const match = providerId.match(/^pp_([^_]+)_(.+)$/);
+  
+  if (match) {
+    return {
+      provider: match[1],
+      method: match[2],
+    };
+  }
+  
+  // Fallback for non-standard formats
+  return {
+    provider: 'unknown',
+    method: providerId,
+  };
+}
+
+/**
+ * Get display name for a provider
+ */
+function getDisplayName(providerName: string): string {
+  return PROVIDER_DISPLAY_NAMES[providerName.toLowerCase()] || 
+         providerName.charAt(0).toUpperCase() + providerName.slice(1);
+}
+
+/**
+ * Transform Medusa payment provider to Thor payment method
+ * 
+ * @param medusaProvider - Medusa payment provider from API
+ * @returns Normalized Thor PaymentMethod
+ */
+export function transformPaymentMethod(
+  medusaProvider: HttpTypes.StorePaymentProvider
+): PaymentMethod {
+  const providerId = medusaProvider.id;
+  const { provider, method } = parseProviderId(providerId);
+  const type = inferPaymentType(providerId);
+  
+  // Determine features based on provider type
+  const isStripe = provider === 'stripe';
+  const isSystemDefault = provider === 'system' || method === 'default';
+  const isPayPal = provider === 'paypal';
+  
+  return {
+    id: providerId,
+    name: getDisplayName(provider),
+    type,
+    isEnabled: true, // Medusa returns only enabled providers by default
+    requiresSetup: !isSystemDefault, // System/manual payment requires no setup
+    metadata: {
+      providerId: provider,
+      methodId: method,
+      originalData: medusaProvider,
+      _backendMapping: {
+        backend: 'medusa',
+        originalId: providerId,
+        normalizedType: type,
+      },
+    },
+    features: {
+      // Stripe supports saving payment methods
+      saveForLater: isStripe,
+      
+      // Stripe requires 3DS for SCA compliance
+      requires3DS: isStripe,
+      
+      // Most providers support refunds except COD/manual
+      supportsRefunds: !isSystemDefault,
+      
+      // Stripe has minimum amounts (varies by currency)
+      minAmount: isStripe ? 50 : undefined, // 50 cents minimum for Stripe
+      
+      // PayPal has maximum transaction limits
+      maxAmount: isPayPal ? 1000000 : undefined, // $10,000 for PayPal
+    },
+  };
+}
+
+/**
+ * Get payment methods for Medusa
+ * 
+ * Queries Medusa API for available payment providers in a region.
+ * Medusa requires either regionId or cartId to determine available providers.
+ * 
+ * @param sdk - Medusa SDK instance
+ * @param options - Payment methods query options
+ * @returns Array of normalized payment methods
+ * 
+ * @throws {Error} If neither regionId nor cartId is provided
+ * @throws {ProviderAPIError} If API request fails
+ */
+export async function getPaymentMethods(
+  sdk: Medusa,
+  options: PaymentMethodsOptions
+): Promise<PaymentMethod[]> {
+  // Medusa requires region_id to list payment providers
+  let regionId = options.regionId;
+  
+  // If cart ID is provided but no region, fetch cart to get region
+  if (options.cartId && !regionId) {
+    try {
+      const { cart } = await sdk.store.cart.retrieve(options.cartId);
+      regionId = cart.region_id;
+    } catch (error) {
+      const err = error as any;
+      throw new ProviderAPIError(
+        'Failed to fetch cart to determine region',
+        'medusa',
+        err?.status
+      );
+    }
+  }
+  
+  // Validate that we have a region ID
+  if (!regionId) {
+    throw new Error(
+      'Either regionId or cartId is required for Medusa payment methods. ' +
+      'Medusa requires a region to determine available payment providers.'
+    );
+  }
+  
+  try {
+    // Query Medusa API for payment providers in this region
+    const response = await sdk.store.payment.listPaymentProviders({
+      region_id: regionId,
+    });
+    
+    // Transform to Thor format
+    let methods = response.payment_providers.map(transformPaymentMethod);
+    
+    // Apply filters
+    if (options.enabledOnly !== false) { // Default to true
+      methods = methods.filter(m => m.isEnabled);
+    }
+    
+    // Filter by currency if provided
+    if (options.currencyCode) {
+      methods = methods.filter(m => {
+        // If method specifies supported currencies, check them
+        if (m.features?.supportedCurrencies) {
+          return m.features.supportedCurrencies.includes(options.currencyCode!);
+        }
+        // Otherwise assume all currencies supported
+        return true;
+      });
+    }
+    
+    return methods;
+  } catch (error) {
+    const err = error as any;
+    throw new ProviderAPIError(
+      'Failed to fetch payment providers from Medusa',
+      'medusa',
+      err?.status
+    );
+  }
+}