@thorprovider/adapters 4.2.1 → 5.0.0

package/src/providers/shopify/auth.ts

@@ -1,402 +0,0 @@
-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);
-  }
-}