@thorprovider/adapters 5.0.0 → 5.0.2

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);
+  }
+}