@thorprovider/adapters 4.0.1 → 4.1.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@thorprovider/adapters",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "Framework-agnostic commerce adapters for Thor Commerce ecosystem - Multi-platform support with unified API",
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "restricted"
+    "access": "public"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/lib/auth-storage.ts

@@ -0,0 +1,101 @@
+import type { AuthConfig } from '@thorprovider/types';
+
+type StoredValue = string | null;
+
+function isBrowserStorageAvailable(): boolean {
+  return typeof window !== 'undefined';
+}
+
+function getStorage(config: AuthConfig): Storage | null {
+  if (!isBrowserStorageAvailable()) {
+    return null;
+  }
+
+  switch (config.storage) {
+    case 'localStorage':
+      return window.localStorage;
+    case 'sessionStorage':
+      return window.sessionStorage;
+    default:
+      return null;
+  }
+}
+
+export class AuthStorage {
+  private memory = new Map<string, string>();
+
+  constructor(
+    private readonly config: AuthConfig,
+    private readonly namespace: string,
+  ) {}
+
+  private key(suffix: string): string {
+    return `${this.namespace}:${suffix}`;
+  }
+
+  async getString(suffix: string): Promise<StoredValue> {
+    const key = this.key(suffix);
+
+    if (this.config.customStorage) {
+      return (await this.config.customStorage.getItem(key)) ?? null;
+    }
+
+    const browserStorage = getStorage(this.config);
+    if (browserStorage) {
+      return browserStorage.getItem(key);
+    }
+
+    return this.memory.get(key) ?? null;
+  }
+
+  async setString(suffix: string, value: string): Promise<void> {
+    const key = this.key(suffix);
+
+    if (this.config.customStorage) {
+      await this.config.customStorage.setItem(key, value);
+      return;
+    }
+
+    const browserStorage = getStorage(this.config);
+    if (browserStorage) {
+      browserStorage.setItem(key, value);
+      return;
+    }
+
+    this.memory.set(key, value);
+  }
+
+  async remove(suffix: string): Promise<void> {
+    const key = this.key(suffix);
+
+    if (this.config.customStorage) {
+      await this.config.customStorage.removeItem(key);
+      return;
+    }
+
+    const browserStorage = getStorage(this.config);
+    if (browserStorage) {
+      browserStorage.removeItem(key);
+      return;
+    }
+
+    this.memory.delete(key);
+  }
+
+  async getJson<T>(suffix: string): Promise<T | null> {
+    const value = await this.getString(suffix);
+    if (!value) {
+      return null;
+    }
+
+    try {
+      return JSON.parse(value) as T;
+    } catch {
+      return null;
+    }
+  }
+
+  async setJson(suffix: string, value: unknown): Promise<void> {
+    await this.setString(suffix, JSON.stringify(value));
+  }
+}

package/src/providers/shopify/auth.ts

@@ -0,0 +1,402 @@
+import type {
+  Address,
+  AuthConfig,
+  AuthProvider,
+  AuthResponse,
+  CreateAddressData,
+  Customer,
+  LoginCredentials,
+  RegisterData,
+  UpdateCustomerData,
+} from '@thorprovider/types';
+import { createLogger } from '../../core/logger';
+import { ProviderAPIError, extractErrorMessage } from '../../core/errors';
+import { AuthStorage } from '../../lib/auth-storage';
+import {
+  CUSTOMER_ACCESS_TOKEN_CREATE,
+  CUSTOMER_ACCESS_TOKEN_DELETE,
+  CUSTOMER_ADDRESS_CREATE,
+  CUSTOMER_ADDRESS_DELETE,
+  CUSTOMER_ADDRESS_UPDATE,
+  CUSTOMER_CREATE,
+  CUSTOMER_RECOVER,
+  CUSTOMER_RESET,
+  CUSTOMER_UPDATE,
+} from './mutations';
+import { GET_CUSTOMER } from './queries';
+import { transformAddress, transformCustomer, transformCustomerAddresses } from './transforms';
+
+type ShopifyGraphqlRequester = <T = any>(gql: string, variables?: Record<string, unknown>) => Promise<T>;
+
+interface ShopifyCustomerToken {
+  accessToken: string;
+  expiresAt?: string;
+}
+
+interface ShopifyAuthDependencies {
+  query: ShopifyGraphqlRequester;
+  authConfig: AuthConfig;
+  debug?: boolean;
+}
+
+export class ShopifyAuthProvider implements AuthProvider {
+  private readonly logger;
+  private readonly storage: AuthStorage;
+
+  constructor(private readonly deps: ShopifyAuthDependencies) {
+    this.logger = createLogger('ShopifyAuthProvider', deps.debug);
+    this.storage = new AuthStorage(deps.authConfig, 'thor:shopify:auth');
+  }
+
+  private async readToken(): Promise<ShopifyCustomerToken | null> {
+    const token = await this.storage.getJson<ShopifyCustomerToken>('customer-access-token');
+    if (!token?.accessToken) {
+      return null;
+    }
+
+    if (token.expiresAt && new Date(token.expiresAt).getTime() <= Date.now()) {
+      await this.storage.remove('customer-access-token');
+      return null;
+    }
+
+    return token;
+  }
+
+  async getStoredToken(): Promise<ShopifyCustomerToken | null> {
+    return this.readToken();
+  }
+
+  private async writeToken(token: ShopifyCustomerToken | null): Promise<void> {
+    if (!token) {
+      await this.storage.remove('customer-access-token');
+      return;
+    }
+
+    await this.storage.setJson('customer-access-token', token);
+  }
+
+  private async requireToken(): Promise<ShopifyCustomerToken> {
+    const token = await this.readToken();
+    if (!token) {
+      throw new ProviderAPIError('Shopify customer access token is required.', 'shopify', 401);
+    }
+    return token;
+  }
+
+  private async fetchCurrentCustomer(): Promise<any | null> {
+    const token = await this.readToken();
+    if (!token) {
+      return null;
+    }
+
+    try {
+      const data = await this.deps.query<{ customer: any }>(GET_CUSTOMER, {
+        customerAccessToken: token.accessToken,
+      });
+
+      return data.customer ?? null;
+    } catch (error) {
+      await this.writeToken(null);
+      this.logger.warn('Failed to fetch current Shopify customer', extractErrorMessage(error));
+      return null;
+    }
+  }
+
+  async login(credentials: LoginCredentials): Promise<AuthResponse> {
+    try {
+      const data = await this.deps.query<{
+        customerAccessTokenCreate: {
+          customerAccessToken?: ShopifyCustomerToken;
+          customerUserErrors?: Array<{ message: string }>;
+        };
+      }>(CUSTOMER_ACCESS_TOKEN_CREATE, {
+        input: {
+          email: credentials.email,
+          password: credentials.password,
+        },
+      });
+
+      const result = data.customerAccessTokenCreate;
+      if (result.customerUserErrors?.length || !result.customerAccessToken?.accessToken) {
+        throw new ProviderAPIError(
+          result.customerUserErrors?.map((entry) => entry.message).join('; ') || 'Shopify login failed.',
+          'shopify',
+          400,
+        );
+      }
+
+      await this.writeToken(result.customerAccessToken);
+      const customer = await this.getCurrentCustomer();
+
+      return {
+        token: result.customerAccessToken.accessToken,
+        customer: customer ?? undefined,
+      };
+    } catch (error) {
+      throw new ProviderAPIError(`Shopify login failed: ${extractErrorMessage(error)}`, 'shopify', 400);
+    }
+  }
+
+  async register(data: RegisterData): Promise<AuthResponse> {
+    try {
+      const createResult = await this.deps.query<{
+        customerCreate: {
+          customer?: any;
+          customerUserErrors?: Array<{ message: string }>;
+        };
+      }>(CUSTOMER_CREATE, {
+        input: {
+          firstName: data.first_name,
+          lastName: data.last_name,
+          email: data.email,
+          phone: data.phone,
+          password: data.password,
+        },
+      });
+
+      const result = createResult.customerCreate;
+      if (result.customerUserErrors?.length) {
+        throw new ProviderAPIError(
+          result.customerUserErrors.map((entry) => entry.message).join('; '),
+          'shopify',
+          400,
+        );
+      }
+
+      return this.login({ email: data.email, password: data.password });
+    } catch (error) {
+      throw new ProviderAPIError(`Shopify registration failed: ${extractErrorMessage(error)}`, 'shopify', 400);
+    }
+  }
+
+  async logout(): Promise<void> {
+    try {
+      const token = await this.readToken();
+      if (token?.accessToken) {
+        await this.deps.query(CUSTOMER_ACCESS_TOKEN_DELETE, {
+          customerAccessToken: token.accessToken,
+        });
+      }
+    } catch (error) {
+      this.logger.warn('Shopify logout returned an error', extractErrorMessage(error));
+    } finally {
+      await this.writeToken(null);
+    }
+  }
+
+  async requestPasswordReset(email: string): Promise<void> {
+    try {
+      const data = await this.deps.query<{
+        customerRecover: {
+          customerUserErrors?: Array<{ message: string }>;
+        };
+      }>(CUSTOMER_RECOVER, { email });
+
+      if (data.customerRecover.customerUserErrors?.length) {
+        throw new ProviderAPIError(
+          data.customerRecover.customerUserErrors.map((entry) => entry.message).join('; '),
+          'shopify',
+          400,
+        );
+      }
+    } catch (error) {
+      throw new ProviderAPIError(`Shopify password reset request failed: ${extractErrorMessage(error)}`, 'shopify', 400);
+    }
+  }
+
+  async resetPassword(token: string, password: string, metadata?: Record<string, unknown>): Promise<void> {
+    const customerId = typeof metadata?.customerId === 'string' ? metadata.customerId : null;
+    if (!customerId) {
+      throw new ProviderAPIError('Shopify password reset requires metadata.customerId.', 'shopify', 400);
+    }
+
+    try {
+      const data = await this.deps.query<{
+        customerReset: {
+          customerAccessToken?: ShopifyCustomerToken;
+          customerUserErrors?: Array<{ message: string }>;
+        };
+      }>(CUSTOMER_RESET, {
+        id: customerId,
+        input: {
+          resetToken: token,
+          password,
+        },
+      });
+
+      if (data.customerReset.customerUserErrors?.length) {
+        throw new ProviderAPIError(
+          data.customerReset.customerUserErrors.map((entry) => entry.message).join('; '),
+          'shopify',
+          400,
+        );
+      }
+
+      if (data.customerReset.customerAccessToken?.accessToken) {
+        await this.writeToken(data.customerReset.customerAccessToken);
+      }
+    } catch (error) {
+      throw new ProviderAPIError(`Shopify password reset failed: ${extractErrorMessage(error)}`, 'shopify', 400);
+    }
+  }
+
+  async getCurrentCustomer(): Promise<Customer | null> {
+    const customer = await this.fetchCurrentCustomer();
+    return customer ? transformCustomer(customer) : null;
+  }
+
+  async updateCustomer(data: UpdateCustomerData): Promise<Customer> {
+    const token = await this.requireToken();
+
+    try {
+      const payload: Record<string, unknown> = {};
+      if (data.first_name !== undefined) payload.firstName = data.first_name;
+      if (data.last_name !== undefined) payload.lastName = data.last_name;
+      if (data.email !== undefined) payload.email = data.email;
+      if (data.phone !== undefined && data.phone !== null) payload.phone = data.phone;
+      if (data.password !== undefined) payload.password = data.password;
+
+      const response = await this.deps.query<{
+        customerUpdate: {
+          customer?: any;
+          customerAccessToken?: ShopifyCustomerToken;
+          customerUserErrors?: Array<{ message: string }>;
+        };
+      }>(CUSTOMER_UPDATE, {
+        customerAccessToken: token.accessToken,
+        customer: payload,
+      });
+
+      const result = response.customerUpdate;
+      if (result.customerUserErrors?.length || !result.customer) {
+        throw new ProviderAPIError(
+          result.customerUserErrors?.map((entry) => entry.message).join('; ') || 'Shopify customer update failed.',
+          'shopify',
+          400,
+        );
+      }
+
+      if (result.customerAccessToken?.accessToken) {
+        await this.writeToken(result.customerAccessToken);
+      }
+
+      return transformCustomer(result.customer);
+    } catch (error) {
+      throw new ProviderAPIError(`Shopify update customer failed: ${extractErrorMessage(error)}`, 'shopify', 400);
+    }
+  }
+
+  async isAuthenticated(): Promise<boolean> {
+    return (await this.getCurrentCustomer()) !== null;
+  }
+
+  getAuthToken(): string | null {
+    return null;
+  }
+
+  async getAddresses(): Promise<Address[]> {
+    const customer = await this.fetchCurrentCustomer();
+    return customer ? transformCustomerAddresses(customer) : [];
+  }
+
+  private toMailingAddressInput(data: Partial<CreateAddressData>): Record<string, unknown> {
+    return {
+      firstName: data.firstName,
+      lastName: data.lastName,
+      company: data.company,
+      address1: data.address1,
+      address2: data.address2,
+      city: data.city,
+      province: data.province,
+      country: data.countryCode,
+      zip: data.postalCode,
+      phone: data.phone,
+    };
+  }
+
+  async createAddress(data: CreateAddressData): Promise<Address> {
+    const token = await this.requireToken();
+
+    try {
+      const response = await this.deps.query<{
+        customerAddressCreate: {
+          customerAddress?: any;
+          customerUserErrors?: Array<{ message: string }>;
+        };
+      }>(CUSTOMER_ADDRESS_CREATE, {
+        customerAccessToken: token.accessToken,
+        address: this.toMailingAddressInput(data),
+      });
+
+      if (response.customerAddressCreate.customerUserErrors?.length || !response.customerAddressCreate.customerAddress) {
+        throw new ProviderAPIError(
+          response.customerAddressCreate.customerUserErrors?.map((entry) => entry.message).join('; ') || 'Shopify address create failed.',
+          'shopify',
+          400,
+        );
+      }
+
+      return transformAddress(response.customerAddressCreate.customerAddress);
+    } catch (error) {
+      throw new ProviderAPIError(`Shopify create address failed: ${extractErrorMessage(error)}`, 'shopify', 400);
+    }
+  }
+
+  async updateAddress(addressId: string, data: Partial<CreateAddressData>): Promise<Address> {
+    const token = await this.requireToken();
+
+    try {
+      const response = await this.deps.query<{
+        customerAddressUpdate: {
+          customerAddress?: any;
+          customerUserErrors?: Array<{ message: string }>;
+        };
+      }>(CUSTOMER_ADDRESS_UPDATE, {
+        customerAccessToken: token.accessToken,
+        id: addressId,
+        address: this.toMailingAddressInput(data),
+      });
+
+      if (response.customerAddressUpdate.customerUserErrors?.length || !response.customerAddressUpdate.customerAddress) {
+        throw new ProviderAPIError(
+          response.customerAddressUpdate.customerUserErrors?.map((entry) => entry.message).join('; ') || 'Shopify address update failed.',
+          'shopify',
+          400,
+        );
+      }
+
+      return transformAddress(response.customerAddressUpdate.customerAddress);
+    } catch (error) {
+      throw new ProviderAPIError(`Shopify update address failed: ${extractErrorMessage(error)}`, 'shopify', 400);
+    }
+  }
+
+  async deleteAddress(addressId: string): Promise<void> {
+    const token = await this.requireToken();
+
+    try {
+      const response = await this.deps.query<{
+        customerAddressDelete: {
+          customerUserErrors?: Array<{ message: string }>;
+        };
+      }>(CUSTOMER_ADDRESS_DELETE, {
+        customerAccessToken: token.accessToken,
+        id: addressId,
+      });
+
+      if (response.customerAddressDelete.customerUserErrors?.length) {
+        throw new ProviderAPIError(
+          response.customerAddressDelete.customerUserErrors.map((entry) => entry.message).join('; '),
+          'shopify',
+          400,
+        );
+      }
+    } catch (error) {
+      throw new ProviderAPIError(`Shopify delete address failed: ${extractErrorMessage(error)}`, 'shopify', 400);
+    }
+  }
+
+  async deleteCustomerAccount(): Promise<void> {
+    throw new ProviderAPIError('Shopify customer self-service deletion requires Admin API and is not supported.', 'shopify', 501);
+  }
+}

package/src/providers/shopify/mutations.ts

@@ -100,3 +100,148 @@ export const CUSTOMER_ACCESS_TOKEN_CREATE = `
     }
   }
 `;
+
+export const CUSTOMER_ACCESS_TOKEN_DELETE = `
+  mutation CustomerAccessTokenDelete($customerAccessToken: String!) {
+    customerAccessTokenDelete(customerAccessToken: $customerAccessToken) {
+      deletedAccessToken
+      deletedCustomerAccessTokenId
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+`;
+
+export const CUSTOMER_CREATE = `
+  mutation CustomerCreate($input: CustomerCreateInput!) {
+    customerCreate(input: $input) {
+      customer {
+        id
+        email
+        firstName
+        lastName
+      }
+      customerUserErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const CUSTOMER_UPDATE = `
+  mutation CustomerUpdate($customerAccessToken: String!, $customer: CustomerUpdateInput!) {
+    customerUpdate(customerAccessToken: $customerAccessToken, customer: $customer) {
+      customer {
+        id
+        email
+        firstName
+        lastName
+        phone
+      }
+      customerAccessToken {
+        accessToken
+        expiresAt
+      }
+      customerUserErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const CUSTOMER_RECOVER = `
+  mutation CustomerRecover($email: String!) {
+    customerRecover(email: $email) {
+      customerUserErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const CUSTOMER_RESET = `
+  mutation CustomerReset($id: ID!, $input: CustomerResetInput!) {
+    customerReset(id: $id, input: $input) {
+      customerAccessToken {
+        accessToken
+        expiresAt
+      }
+      customerUserErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const CUSTOMER_ADDRESS_CREATE = `
+  mutation CustomerAddressCreate($customerAccessToken: String!, $address: MailingAddressInput!) {
+    customerAddressCreate(customerAccessToken: $customerAccessToken, address: $address) {
+      customerAddress {
+        id
+        firstName
+        lastName
+        address1
+        address2
+        city
+        province
+        country
+        zip
+        phone
+        company
+      }
+      customerUserErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const CUSTOMER_ADDRESS_UPDATE = `
+  mutation CustomerAddressUpdate($customerAccessToken: String!, $id: ID!, $address: MailingAddressInput!) {
+    customerAddressUpdate(customerAccessToken: $customerAccessToken, id: $id, address: $address) {
+      customerAddress {
+        id
+        firstName
+        lastName
+        address1
+        address2
+        city
+        province
+        country
+        zip
+        phone
+        company
+      }
+      customerUserErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;
+
+export const CUSTOMER_ADDRESS_DELETE = `
+  mutation CustomerAddressDelete($customerAccessToken: String!, $id: ID!) {
+    customerAddressDelete(customerAccessToken: $customerAccessToken, id: $id) {
+      deletedCustomerAddressId
+      customerUserErrors {
+        field
+        message
+        code
+      }
+    }
+  }
+`;

package/src/providers/shopify/transforms.ts

@@ -171,7 +171,7 @@ export function transformCart(raw: any): Cart {
 // Customer Transforms
 // ============================================
 
-function transformAddress(raw: any): Address {
+export function transformAddress(raw: any): Address {
   return {
     id: raw.id ?? '',
     firstName: raw.firstName ?? '',
@@ -198,6 +198,11 @@ export function transformCustomer(raw: any): Customer {
   };
 }
 
+export function transformCustomerAddresses(raw: any): Address[] {
+  const edges = raw.addresses?.edges ?? [];
+  return edges.map((edge: any) => transformAddress(edge.node));
+}
+
 // ============================================
 // Order Transforms
 // ============================================