@thorprovider/adapters 4.0.1 → 4.2.0

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
 // ============================================

package/src/types/capabilities.types.ts

@@ -16,6 +16,39 @@ import type { BackendCapabilities } from '@thorprovider/types';
 
 export type { BackendCapabilities };
 
+/**
+ * Mock backend capabilities
+ *
+ * Fixture-backed provider used when a storefront has not yet been connected
+ * to a real backend. Supports the minimum commerce flows needed for layout,
+ * preview, navigation, region switching, and cart prototyping.
+ */
+export const MOCK_CAPABILITIES: Readonly<BackendCapabilities> = {
+  updateProfile: false,
+  updateEmail: false,
+  changePasswordDirect: false,
+  changePasswordViaEmail: false,
+  deleteAccount: false,
+  uploadAvatar: false,
+  avatarViaMetadata: false,
+  customAttributes: false,
+  fetchOrders: true,
+  cancelOrder: true,
+  manageAddresses: false,
+  defaultAddress: false,
+  applyDiscounts: true,
+  shippingCalculation: true,
+  guestCheckout: true,
+  savedPaymentMethods: false,
+  listPaymentProviders: true,
+  regionSpecificPayments: true,
+  wishlist: false,
+  advancedSearch: false,
+  facetedFilters: false,
+  productReviews: false,
+  loyaltyProgram: false,
+};
+
 /**
  * Medusa backend capabilities
  * 

package/.turbo/turbo-test.log

@@ -1 +0,0 @@
-command not found: jest

package/publish.log

@@ -1,93 +0,0 @@
-npm warn Unknown project config "network-concurrency". This will stop working in the next major version of npm.
-npm warn publish npm auto-corrected some errors in your package.json when publishing.  Please run "npm pkg fix" to address these errors.
-npm warn publish errors corrected:
-npm warn publish "repository.url" was normalized to "git+https://github.com/thorprovider/thor-commerce.git"
-npm notice
-npm notice 📦  @thor/adapters@3.0.1
-npm notice Tarball Contents
-npm notice 629B AGENTS.md
-npm notice 9.1kB CHANGELOG.md
-npm notice 19.2kB README.md
-npm notice 73.6kB dist/index.d.mts
-npm notice 73.6kB dist/index.d.ts
-npm notice 191.6kB dist/index.js
-npm notice 377.7kB dist/index.js.map
-npm notice 187.4kB dist/index.mjs
-npm notice 377.4kB dist/index.mjs.map
-npm notice 4.7kB docs/authentication.md
-npm notice 4.3kB docs/capabilities-system.md
-npm notice 9.9kB docs/category-customization.md
-npm notice 11.0kB docs/fetch-reliability-solution.md
-npm notice 4.4kB docs/getting-started.md
-npm notice 7.8kB docs/multi-tenant-channel-scoping.md
-npm notice 4.5kB docs/profile-management.md
-npm notice 3.7kB docs/providers-overview.md
-npm notice 2.1kB docs/RETRY_SOLUTION_SUMMARY.md
-npm notice 5.2kB docs/services-overview.md
-npm notice 4.0kB docs/update-documentation.md
-npm notice 1.2kB package.json
-npm notice 6.3kB quick-reference.md
-npm notice 2.5kB src/admin/AdminAuthService.ts
-npm notice 2.4kB src/admin/AdminSessionService.ts
-npm notice 414B src/admin/index.ts
-npm notice 4.2kB src/admin/MetricsService.ts
-npm notice 2.5kB src/backend/BackendMetadataAdapter.ts
-npm notice 3.5kB src/backend/factory.ts
-npm notice 312B src/backend/index.ts
-npm notice 3.9kB src/backend/medusa/MedusaMetadataAdapter.ts
-npm notice 6.3kB src/core/errors.js
-npm notice 3.5kB src/core/errors.ts
-npm notice 11.3kB src/core/fetch-utils.js
-npm notice 6.0kB src/core/fetch-utils.ts
-npm notice 141B src/core/index.ts
-npm notice 2.3kB src/core/logger.js
-npm notice 1.1kB src/core/logger.ts
-npm notice 2.0kB src/factory/index.ts
-npm notice 4.5kB src/index.ts
-npm notice 2.7kB src/lib/money-transform.ts
-npm notice 6.2kB src/metadata/channel-scope-validation.js
-npm notice 5.1kB src/metadata/channel-scope-validation.ts
-npm notice 7.6kB src/metadata/channel-scope.js
-npm notice 8.2kB src/metadata/channel-scope.ts
-npm notice 3.3kB src/metadata/index.js
-npm notice 810B src/metadata/index.ts
-npm notice 148B src/providers/index.ts
-npm notice 30.0kB src/providers/medusa/auth.js
-npm notice 15.1kB src/providers/medusa/auth.ts
-npm notice 6.2kB src/providers/medusa/fulfillment-planner.ts
-npm notice 151.8kB src/providers/medusa/index.js
-npm notice 147.6kB src/providers/medusa/index.ts
-npm notice 184B src/providers/medusa/medusa.ts
-npm notice 11.0kB src/providers/medusa/payment.js
-npm notice 7.2kB src/providers/medusa/payment.ts
-npm notice 25.8kB src/providers/medusa/transforms.js
-npm notice 19.8kB src/providers/medusa/transforms.ts
-npm notice 5.5kB src/resilience/circuit-breaker.ts
-npm notice 238B src/resilience/index.ts
-npm notice 7.6kB src/resilience/README.md
-npm notice 4.8kB src/types/capabilities.types.js
-npm notice 4.7kB src/types/capabilities.types.ts
-npm notice 513B src/types/index.ts
-npm notice 350B src/types/provider.js
-npm notice 365B src/types/provider.ts
-npm notice 6.5kB src/types/ui-responses.ts
-npm notice 1.1kB src/utils/city-coordinates.ts
-npm notice 1.3kB src/utils/geolocation.ts
-npm notice 5.6kB src/utils/payment-utils.js
-npm notice 6.5kB src/utils/payment-utils.ts
-npm notice 357B tsconfig.json
-npm notice 370B tsup.config.ts
-npm notice Tarball Details
-npm notice name: @thor/adapters
-npm notice version: 3.0.1
-npm notice filename: thor-adapters-3.0.1.tgz
-npm notice package size: 413.9 kB
-npm notice unpacked size: 1.9 MB
-npm notice shasum: 696c58c4b5629ad1ec09336238ea157aad015e3d
-npm notice integrity: sha512-tIweHlz73prg8[...]3KYkFTyNlUX4w==
-npm notice total files: 72
-npm notice
-npm notice Publishing to https://npm.pkg.github.com with tag latest and restricted access
-npm error code E401
-npm error 401 Unauthorized - PUT https://npm.pkg.github.com/@thor%2fadapters - unauthenticated: User cannot be authenticated with the token provided.
-npm error A complete log of this run can be found in: /home/nelson/.npm/_logs/2026-04-16T15_45_37_415Z-debug-0.log