@thorprovider/adapters 3.0.2

package/src/providers/medusa/auth.ts

@@ -0,0 +1,496 @@
+/**
+ * @fileoverview Medusa Authentication Provider
+ * @module @thorprovider/adapters/providers/medusa/auth
+ * 
+ * Implementation of AuthProvider for Medusa.js v2
+ * Supports JWT and session-based authentication
+ */
+
+import Medusa from '@medusajs/js-sdk';
+import type {
+  AuthProvider,
+  AuthConfig,
+  LoginCredentials,
+  RegisterData,
+  AuthResponse,
+  Customer,
+  Address,
+  UpdateCustomerData,
+  CreateAddressData,
+  PasswordResetRequest,
+  PasswordResetConfirm,
+} from '@thorprovider/types';
+import { createLogger } from '../../core/logger';
+import { ProviderAPIError } from '../../core/errors';
+import type { Logger } from '../../core/logger';
+import { transformCustomer, transformAddress } from './transforms';
+
+/**
+ * Storage manager for authentication tokens
+ */
+class AuthStorageManager {
+  private storage: AuthConfig['customStorage'] | null = null;
+  private storageType: AuthConfig['storage'];
+  private tokenKey = 'thor_auth_token';
+  
+  constructor(config: AuthConfig) {
+    this.storageType = config.storage;
+    this.storage = config.customStorage ?? null;
+  }
+  
+  async getToken(): Promise<string | null> {
+    if (this.storage) {
+      return this.storage.getItem(this.tokenKey);
+    }
+    
+    if (typeof window === 'undefined') {
+      // Server-side: no storage available
+      return null;
+    }
+    
+    switch (this.storageType) {
+      case 'localStorage':
+        return window.localStorage.getItem(this.tokenKey);
+      case 'sessionStorage':
+        return window.sessionStorage.getItem(this.tokenKey);
+      case 'cookie':
+        // Cookies are handled automatically by fetch, just return null
+        return null;
+      case 'memory':
+        return null;
+      default:
+        return null;
+    }
+  }
+  
+  async setToken(token: string): Promise<void> {
+    if (this.storage) {
+      await this.storage.setItem(this.tokenKey, token);
+      return;
+    }
+    
+    if (typeof window === 'undefined') {
+      return;
+    }
+    
+    switch (this.storageType) {
+      case 'localStorage':
+        window.localStorage.setItem(this.tokenKey, token);
+        break;
+      case 'sessionStorage':
+        window.sessionStorage.setItem(this.tokenKey, token);
+        break;
+      case 'cookie':
+      case 'memory':
+        // No action needed for cookie (handled by SDK) or memory
+        break;
+    }
+  }
+  
+  async removeToken(): Promise<void> {
+    if (this.storage) {
+      await this.storage.removeItem(this.tokenKey);
+      return;
+    }
+    
+    if (typeof window === 'undefined') {
+      return;
+    }
+    
+    switch (this.storageType) {
+      case 'localStorage':
+        window.localStorage.removeItem(this.tokenKey);
+        break;
+      case 'sessionStorage':
+        window.sessionStorage.removeItem(this.tokenKey);
+        break;
+      case 'cookie':
+      case 'memory':
+        // No action needed
+        break;
+    }
+  }
+}
+
+/**
+ * Medusa authentication provider implementation
+ */
+export class MedusaAuthProvider implements AuthProvider {
+  private sdk: Medusa;
+  private logger: ReturnType<typeof createLogger>;
+  private authConfig: AuthConfig;
+  private storageManager: AuthStorageManager;
+  
+  constructor(sdk: Medusa, authConfig: AuthConfig, debug = false) {
+    this.sdk = sdk;
+    this.authConfig = authConfig;
+    this.logger = createLogger('MedusaAuthProvider', debug);
+    this.storageManager = new AuthStorageManager(authConfig);
+    
+    this.logger.info('Medusa Auth Provider initialized', {
+      method: authConfig.method,
+      storage: authConfig.storage,
+    });
+  }
+  
+  // ========================================
+  // Authentication Methods
+  // ========================================
+  
+  async login(credentials: LoginCredentials): Promise<AuthResponse> {
+    this.logger.debug('login', { email: credentials.email });
+    
+    try {
+      // Step 1: Authenticate with Medusa
+      const token = await this.sdk.auth.login('customer', 'emailpass', {
+        email: credentials.email,
+        password: credentials.password,
+      });
+      
+      // Check if token requires additional actions (OAuth flow)
+      if (typeof token !== 'string') {
+        this.logger.warn('Authentication requires additional actions', token);
+        return {
+          requiresAction: true,
+          redirectUrl: token.location,
+        };
+      }
+      
+      // Step 2: Store token based on auth method
+      if (this.authConfig.method === 'jwt') {
+        await this.storageManager.setToken(token);
+      }
+      // Note: For session-based auth, the SDK automatically handles cookies
+      // when auth.login() is called with auth.type='session' in SDK config
+      
+      // Step 3: Fetch customer data
+      const customer = await this.getCurrentCustomer();
+      
+      this.logger.info('Login successful', { customerId: customer?.id });
+      
+      return {
+        token: this.authConfig.method === 'jwt' ? token : undefined,
+        customer: customer ?? undefined,
+      };
+    } catch (error: any) {
+      this.logger.error('Login failed', error);
+      throw new ProviderAPIError(
+        `Authentication failed: ${error.message}`,
+        'LOGIN_FAILED',
+        error
+      );
+    }
+  }
+  
+  async register(data: RegisterData): Promise<AuthResponse> {
+    this.logger.debug('register', { email: data.email });
+    
+    try {
+      // Step 1: Register auth identity with Medusa
+      const token = await this.sdk.auth.register('customer', 'emailpass', {
+        email: data.email,
+        password: data.password,
+      });
+      
+      if (typeof token !== 'string') {
+        throw new Error('Registration returned non-string token');
+      }
+      
+      // Step 2: Create customer profile
+      // Note: The SDK automatically includes the token in the header after auth.register()
+      const { customer } = await this.sdk.store.customer.create({
+        email: data.email,
+        first_name: data.first_name,
+        last_name: data.last_name,
+        phone: data.phone,
+      });
+      
+      // Step 3: Store token based on auth method
+      if (this.authConfig.method === 'jwt') {
+        await this.storageManager.setToken(token);
+      }
+      // Note: For session-based auth, the SDK automatically handles cookies
+      // when auth.register() is called with auth.type='session' in SDK config
+      
+      this.logger.info('Registration successful', { customerId: customer.id });
+      
+      return {
+        token: this.authConfig.method === 'jwt' ? token : undefined,
+        customer: transformCustomer(customer, customer.email),
+      };
+    } catch (error: any) {
+      this.logger.error('Registration failed', error);
+      throw new ProviderAPIError(
+        `Registration failed: ${error.message}`,
+        'REGISTRATION_FAILED',
+        error
+      );
+    }
+  }
+  
+  async logout(): Promise<void> {
+    this.logger.debug('logout');
+    
+    try {
+      await this.storageManager.removeToken();
+      
+      // For session auth, also call logout endpoint
+      if (this.authConfig.method === 'session') {
+        await this.sdk.auth.logout();
+      }
+      
+      this.logger.info('Logout successful');
+    } catch (error: any) {
+      this.logger.error('Logout failed', error);
+      // Don't throw error on logout failure, just log it
+    }
+  }
+  
+  // ========================================
+  // Password Management
+  // ========================================
+  
+  async requestPasswordReset(email: string): Promise<void> {
+    this.logger.debug('requestPasswordReset', { email });
+    
+    try {
+      await this.sdk.auth.resetPassword('customer', 'emailpass', {
+        identifier: email,
+      });
+      
+      this.logger.info('Password reset email sent', { email });
+    } catch (error: any) {
+      this.logger.error('Password reset request failed', error);
+      throw new ProviderAPIError(
+        `Password reset request failed: ${error.message}`,
+        'PASSWORD_RESET_FAILED',
+        error
+      );
+    }
+  }
+  
+  async resetPassword(
+    token: string,
+    password: string,
+    metadata?: Record<string, unknown>
+  ): Promise<void> {
+    this.logger.debug('resetPassword', { hasMetadata: !!metadata });
+    
+    // Medusa requires email in the request body
+    // Extract from metadata or decode from token
+    const email = metadata?.email as string | undefined;
+    
+    if (!email) {
+      throw new ProviderAPIError(
+        'Email is required in metadata for Medusa password reset',
+        'MEDUSA_AUTH_PROVIDER',
+        400
+      );
+    }
+    
+    try {
+      // Medusa v2.6+ API: email + password in body, token as 3rd param
+      await this.sdk.auth.updateProvider('customer', 'emailpass', {
+        email,
+        password,
+      }, token);
+      
+      this.logger.info('Password reset successful');
+    } catch (error: any) {
+      this.logger.error('Password reset failed', error);
+      throw new ProviderAPIError(
+        `Password reset failed: ${error.message}`,
+        'PASSWORD_RESET_CONFIRM_FAILED',
+        error
+      );
+    }
+  }
+  
+  // ========================================
+  // Session Management
+  // ========================================
+  
+  async getCurrentCustomer(): Promise<Customer | null> {
+    this.logger.debug('getCurrentCustomer');
+    
+    try {
+      const { customer } = await this.sdk.store.customer.retrieve();
+      
+      if (!customer) {
+        return null;
+      }
+      
+      return transformCustomer(customer, customer.email);
+    } catch (error: any) {
+      this.logger.debug('No authenticated customer');
+      return null;
+    }
+  }
+  
+  async updateCustomer(data: UpdateCustomerData): Promise<Customer> {
+    this.logger.debug('updateCustomer');
+    
+    try {
+      const updateData = { ...data };
+      if (updateData.phone === null) {
+        delete updateData.phone; // Medusa doesn't accept null, only undefined
+      }
+      const { customer } = await this.sdk.store.customer.update(updateData as any);
+      
+      return transformCustomer(customer, customer.email);
+    } catch (error: any) {
+      this.logger.error('Update customer failed', error);
+      throw new ProviderAPIError(
+        `Failed to update customer: ${error.message}`,
+        'UPDATE_CUSTOMER_FAILED',
+        error
+      );
+    }
+  }
+  
+  async isAuthenticated(): Promise<boolean> {
+    const customer = await this.getCurrentCustomer();
+    return customer !== null;
+  }
+  
+  getAuthToken(): string | null {
+    // For JWT auth, return stored token
+    if (this.authConfig.method === 'jwt') {
+      // This is sync, so we can't use async storage
+      // Return null and rely on storage manager
+      return null;
+    }
+    
+    // For session auth, return null (cookies are handled automatically)
+    return null;
+  }
+  
+  // ========================================
+  // Address Management
+  // ========================================
+  
+  async getAddresses(): Promise<Address[]> {
+    this.logger.debug('getAddresses');
+    try {
+      const { addresses } = await this.sdk.store.customer.listAddress();
+      return addresses.map((address: any) => transformAddress(address));
+    } catch (error: any) {
+      this.logger.error('Get addresses failed', error);
+      throw new ProviderAPIError(
+        `Failed to get addresses: ${error.message}`,
+        'GET_ADDRESSES_FAILED',
+        error
+      );
+    }
+  }
+  
+  async createAddress(data: CreateAddressData): Promise<Address> {
+    this.logger.debug('createAddress');
+    
+    try {
+      // Transform camelCase to snake_case for Medusa API
+      const medusaData = {
+        first_name: data.firstName,
+        last_name: data.lastName,
+        company: data.company,
+        address_1: data.address1,
+        address_2: data.address2,
+        city: data.city,
+        province: data.province,
+        postal_code: data.postalCode,
+        country_code: data.countryCode,
+        phone: data.phone,
+        metadata: data.metadata,
+      };
+      
+      const { customer } = await this.sdk.store.customer.createAddress(medusaData);
+      
+      // Get the most recent address (last one in array)
+      const addresses = customer.addresses || [];
+      const address = addresses[addresses.length - 1];
+      
+      if (!address) {
+        throw new Error('No address returned from createAddress');
+      }
+      
+      return transformAddress(address);
+    } catch (error: any) {
+      this.logger.error('Create address failed', error);
+      throw new ProviderAPIError(
+        `Failed to create address: ${error.message}`,
+        'CREATE_ADDRESS_FAILED',
+        error
+      );
+    }
+  }
+  
+  async updateAddress(
+    addressId: string,
+    data: Partial<CreateAddressData>
+  ): Promise<Address> {
+    this.logger.debug('updateAddress', { addressId });
+    
+    try {
+      // Transform camelCase to snake_case for Medusa API (partial)
+      const medusaData: any = {};
+      if (data.firstName !== undefined) medusaData.first_name = data.firstName;
+      if (data.lastName !== undefined) medusaData.last_name = data.lastName;
+      if (data.company !== undefined) medusaData.company = data.company;
+      if (data.address1 !== undefined) medusaData.address_1 = data.address1;
+      if (data.address2 !== undefined) medusaData.address_2 = data.address2;
+      if (data.city !== undefined) medusaData.city = data.city;
+      if (data.province !== undefined) medusaData.province = data.province;
+      if (data.postalCode !== undefined) medusaData.postal_code = data.postalCode;
+      if (data.countryCode !== undefined) medusaData.country_code = data.countryCode;
+      if (data.phone !== undefined) medusaData.phone = data.phone;
+      if (data.metadata !== undefined) medusaData.metadata = data.metadata;
+      
+      const { customer } = await this.sdk.store.customer.updateAddress(addressId, medusaData);
+      
+      // Find the updated address by ID
+      const addresses = customer.addresses || [];
+      const address = addresses.find((addr: any) => addr.id === addressId);
+      
+      if (!address) {
+        throw new Error(`Address ${addressId} not found after update`);
+      }
+      
+      return transformAddress(address);
+    } catch (error: any) {
+      this.logger.error('Update address failed', error);
+      throw new ProviderAPIError(
+        `Failed to update address: ${error.message}`,
+        'UPDATE_ADDRESS_FAILED',
+        error
+      );
+    }
+  }
+  
+  async deleteAddress(addressId: string): Promise<void> {
+    this.logger.debug('deleteAddress', { addressId });
+    
+    try {
+      await this.sdk.store.customer.deleteAddress(addressId);
+      this.logger.info('Address deleted', { addressId });
+    } catch (error: any) {
+      this.logger.error('Delete address failed', error);
+      throw new ProviderAPIError(
+        `Failed to delete address: ${error.message}`,
+        'DELETE_ADDRESS_FAILED',
+        error
+      );
+    }
+  }
+
+  async deleteCustomerAccount(): Promise<void> {
+    this.logger.debug('deleteCustomerAccount');
+    
+    // TODO: Implement when custom Medusa backend endpoint is ready
+    // DELETE /store/customers/me
+    throw new ProviderAPIError(
+      'Delete customer account is not yet implemented. Requires custom Medusa backend endpoint.',
+      'NOT_IMPLEMENTED',
+      undefined
+    );
+  }
+}

package/src/providers/medusa/fulfillment-planner.ts

@@ -0,0 +1,225 @@
+/**
+ * Fulfillment planner
+ *
+ * Plans an optimal fulfillment strategy for cart items given:
+ * - available stock locations
+ * - inventory levels per variant
+ * - an optional shipping address (for proximity sorting)
+ */
+
+import type { CartItem, InventoryLevel, StockLocation, FulfillmentOption } from '@thorprovider/types';
+import { calculateDistance, geocodeAddress, type Coordinates } from '../../utils/geolocation';
+
+export interface FulfillmentGroup {
+  locationId: string;
+  locationName: string;
+  items: Array<{
+    variantId: string;
+    quantity: number;
+    productName: string;
+  }>;
+  shippingOptions: FulfillmentOption[];
+}
+
+export interface FulfillmentPlan {
+  canFulfill: boolean;
+  groups: FulfillmentGroup[];
+  shippingAddress?: Coordinates;
+}
+
+export interface PlanFulfillmentShippingAddress {
+  city?: string;
+  countryCode?: string;
+  postalCode?: string;
+}
+
+interface InventoryMap {
+  [variantId: string]: InventoryLevel[];
+}
+
+export async function planFulfillment(
+  cartItems: CartItem[],
+  stockLocations: StockLocation[],
+  inventoryLevels: InventoryMap,
+  shippingAddress?: PlanFulfillmentShippingAddress,
+): Promise<FulfillmentPlan> {
+  if (cartItems.length === 0) {
+    return { canFulfill: true, groups: [] };
+  }
+
+  let addressCoords: Coordinates | null = null;
+  if (shippingAddress) {
+    addressCoords = await geocodeAddress(shippingAddress);
+  }
+
+  const itemLocationMap = new Map<string, string[]>();
+
+  for (const item of cartItems) {
+    const variantId = item.merchandise.id;
+    const levels = inventoryLevels[variantId] ?? [];
+
+    const availableLocations = levels
+      .filter((level) => level.availableQuantity >= item.quantity)
+      .map((level) => level.locationId);
+
+    itemLocationMap.set(variantId, availableLocations);
+  }
+
+  const singleLocationPlan = findSingleLocationFulfillment(
+    cartItems,
+    stockLocations,
+    itemLocationMap,
+    addressCoords,
+  );
+
+  if (singleLocationPlan) {
+    return {
+      canFulfill: true,
+      groups: [singleLocationPlan],
+      shippingAddress: addressCoords ?? undefined,
+    };
+  }
+
+  const splitPlan = findSplitFulfillment(cartItems, stockLocations, inventoryLevels, addressCoords);
+
+  return {
+    canFulfill: splitPlan.groups.length > 0,
+    groups: splitPlan.groups,
+    shippingAddress: addressCoords ?? undefined,
+  };
+}
+
+function findSingleLocationFulfillment(
+  items: CartItem[],
+  locations: StockLocation[],
+  itemLocationMap: Map<string, string[]>,
+  shippingCoords: Coordinates | null,
+): FulfillmentGroup | null {
+  const firstVariantId = items[0]?.merchandise?.id;
+  if (!firstVariantId) return null;
+
+  const firstItemLocations = itemLocationMap.get(firstVariantId);
+  if (!firstItemLocations || firstItemLocations.length === 0) {
+    return null;
+  }
+
+  const locationCandidates = new Set<string>(firstItemLocations);
+
+  for (let i = 1; i < items.length; i++) {
+    const variantId = items[i]?.merchandise?.id;
+    if (!variantId) return null;
+
+    const itemLocations = itemLocationMap.get(variantId) ?? [];
+    const itemLocationsSet = new Set(itemLocations);
+
+    for (const loc of locationCandidates) {
+      if (!itemLocationsSet.has(loc)) {
+        locationCandidates.delete(loc);
+      }
+    }
+
+    if (locationCandidates.size === 0) return null;
+  }
+
+  let selectedLocationId = Array.from(locationCandidates)[0];
+
+  if (shippingCoords) {
+    let minDistance = Infinity;
+
+    for (const locId of locationCandidates) {
+      const location = locations.find((l) => l.id === locId);
+      const lat = location?.metadata?.lat;
+      const lng = location?.metadata?.lng;
+      if (typeof lat !== 'number' || typeof lng !== 'number') continue;
+
+      const distance = calculateDistance(shippingCoords, { lat, lng });
+      if (distance < minDistance) {
+        minDistance = distance;
+        selectedLocationId = locId;
+      }
+    }
+  }
+
+  const selectedLocation = locations.find((l) => l.id === selectedLocationId);
+  if (!selectedLocation) return null;
+
+  return {
+    locationId: selectedLocationId,
+    locationName: selectedLocation.name,
+    items: items.map((item) => ({
+      variantId: item.merchandise.id,
+      quantity: item.quantity,
+      productName: item.merchandise.product.title,
+    })),
+    shippingOptions: [],
+  };
+}
+
+function findSplitFulfillment(
+  items: CartItem[],
+  locations: StockLocation[],
+  inventoryLevels: InventoryMap,
+  shippingCoords: Coordinates | null,
+): { groups: FulfillmentGroup[] } {
+  const groups: FulfillmentGroup[] = [];
+  const assignedVariantIds = new Set<string>();
+
+  const sortedLocations = sortLocationsByProximity(locations, shippingCoords);
+
+  for (const location of sortedLocations) {
+    const groupItems: FulfillmentGroup['items'] = [];
+
+    for (const item of items) {
+      const variantId = item.merchandise.id;
+      if (assignedVariantIds.has(variantId)) continue;
+
+      const levels = inventoryLevels[variantId] ?? [];
+      const levelAtLocation = levels.find((l) => l.locationId === location.id);
+
+      if (levelAtLocation && levelAtLocation.availableQuantity >= item.quantity) {
+        groupItems.push({
+          variantId,
+          quantity: item.quantity,
+          productName: item.merchandise.product.title,
+        });
+        assignedVariantIds.add(variantId);
+      }
+    }
+
+    if (groupItems.length > 0) {
+      groups.push({
+        locationId: location.id,
+        locationName: location.name,
+        items: groupItems,
+        shippingOptions: [],
+      });
+    }
+
+    if (assignedVariantIds.size === items.length) {
+      break;
+    }
+  }
+
+  return { groups };
+}
+
+function sortLocationsByProximity(
+  locations: StockLocation[],
+  shippingCoords: Coordinates | null,
+): StockLocation[] {
+  if (!shippingCoords) return [...locations];
+
+  return [...locations].sort((a, b) => {
+    const distA =
+      typeof a.metadata?.lat === 'number' && typeof a.metadata?.lng === 'number'
+        ? calculateDistance(shippingCoords, { lat: a.metadata.lat, lng: a.metadata.lng })
+        : Infinity;
+
+    const distB =
+      typeof b.metadata?.lat === 'number' && typeof b.metadata?.lng === 'number'
+        ? calculateDistance(shippingCoords, { lat: b.metadata.lat, lng: b.metadata.lng })
+        : Infinity;
+
+    return distA - distB;
+  });
+}