@doswiftly/storefront-sdk 4.0.0

package/README.md

@@ -0,0 +1,430 @@
+# @doswiftly/storefront-sdk
+
+Layered runtime SDK for DoSwiftly Commerce storefronts. Hydrogen-aligned architecture with **0 runtime dependencies** in core.
+
+## Architecture
+
+```
+@doswiftly/storefront-sdk
+├── core (.)              — Framework-agnostic: transport, middleware, CartClient, AuthClient,
+│                           cache, format utilities, sanitizeHtml, normalizeConnection,
+│                           auth cookie config/handlers/token client, route matching
+├── react (./react)       — React adapter: providers, Zustand stores (Context-based), hooks,
+│                           useHydrated, useDebouncedValue, createStoreContext
+├── react/server          — Server-side client factory
+└── cache (./cache)       — Cache strategy functions
+```
+
+**Core** works everywhere: Node.js, Edge Workers, Deno, Bun, CLI scripts — without React.
+**React adapter** requires `react ^18 || ^19` and `zustand ^5` as peer dependencies.
+
+## Installation
+
+```bash
+pnpm add @doswiftly/storefront-sdk
+```
+
+## Quick Start
+
+### Core (framework-agnostic)
+
+```typescript
+import {
+  createStorefrontClient,
+  authMiddleware,
+  currencyMiddleware,
+  retryMiddleware,
+  timeoutMiddleware,
+  errorMiddleware,
+  CartClient,
+  AuthClient,
+} from '@doswiftly/storefront-sdk';
+
+const client = createStorefrontClient({
+  apiUrl: 'https://api.doswiftly.pl',
+  shopSlug: 'my-shop',
+  middleware: [
+    authMiddleware(() => getToken()),
+    currencyMiddleware(() => getCurrency()),
+    retryMiddleware({ maxRetries: 2 }),
+    timeoutMiddleware({ timeout: 5000 }),
+    errorMiddleware(), // ALWAYS LAST
+  ],
+});
+
+// Query (deduplicated, cached)
+const data = await client.query(ProductQuery, { handle: 'foo' }, cacheLong());
+
+// Mutation (never cached, never retried)
+const result = await client.mutate(CartCreateMutation, { input: {} });
+```
+
+### React (Next.js)
+
+```tsx
+// app/layout.tsx
+import { StorefrontProvider } from '@doswiftly/storefront-sdk/react';
+
+export default function Layout({ children }) {
+  return (
+    <StorefrontProvider
+      config={{ apiUrl: process.env.NEXT_PUBLIC_API_URL!, shopSlug: process.env.NEXT_PUBLIC_SHOP_SLUG! }}
+      shopData={shopData}
+    >
+      {children}
+    </StorefrontProvider>
+  );
+}
+```
+
+```tsx
+// Client Component
+'use client';
+import { useAuth, useCartManager, useAuthStore, useCurrencyStore, useAuthHydrated } from '@doswiftly/storefront-sdk/react';
+
+const { login, logout } = useAuth({ onSetToken, onClearToken });
+const { addItem, removeItem, lines, isLoading } = useCartManager();
+const { isAuthenticated, customer } = useAuthStore();
+const authHydrated = useAuthHydrated(); // true after persist rehydration
+const { currency, setCurrency } = useCurrencyStore();
+```
+
+## Export Paths
+
+| Path | Description | Dependencies |
+|------|-------------|-------------|
+| `@doswiftly/storefront-sdk` | Core: transport, middleware, clients, errors, format, sanitize, auth handlers, route matching | **0** |
+| `@doswiftly/storefront-sdk/react` | Providers, hooks, store hooks, useHydrated, useDebouncedValue, createStoreContext | react, zustand |
+| `@doswiftly/storefront-sdk/react/server` | Server-side client factory | react |
+| `@doswiftly/storefront-sdk/cache` | Cache strategy functions | **0** |
+
+## Core API
+
+### createStorefrontClient
+
+```typescript
+const client = createStorefrontClient({
+  apiUrl: string,
+  shopSlug: string,
+  middleware?: Middleware[],
+  defaultHeaders?: Record<string, string>,
+  fetch?: typeof globalThis.fetch, // custom fetch (polyfill, test mocks)
+  debug?: boolean,                 // log requests in dev
+});
+
+client.query<T, V>(document, variables?, cache?): Promise<T>
+client.mutate<T, V>(document, variables?): Promise<T>
+client.use(middleware): void // imperative middleware add
+```
+
+Features: lazy pipeline compilation, same-tick request deduplication, TypedDocumentString support.
+
+### Middleware Pipeline
+
+Order matters: `auth → currency → [custom] → retry → timeout → errors (LAST)`
+
+```typescript
+import {
+  authMiddleware,      // Authorization: Bearer {token}
+  currencyMiddleware,  // X-Preferred-Currency header
+  retryMiddleware,     // Exponential backoff (queries only, not mutations)
+  timeoutMiddleware,   // AbortController, edge-safe (default 5s)
+  errorMiddleware,     // Normalizes all errors → StorefrontError (ALWAYS LAST)
+} from '@doswiftly/storefront-sdk';
+
+// Custom middleware
+const logMiddleware: Middleware = async (req, next) => {
+  console.log('Request:', req.operationName);
+  const response = await next(req);
+  console.log('Response:', response.status);
+  return response;
+};
+```
+
+### CartClient
+
+```typescript
+const cartClient = new CartClient(client);
+
+const cart = await cartClient.create();
+const updated = await cartClient.addItems(cartId, [{ merchandiseId: 'v-123', quantity: 1 }]);
+await cartClient.updateItems(cartId, [{ id: 'line-1', quantity: 3 }]);
+await cartClient.removeItems(cartId, ['line-1']);
+await cartClient.updateDiscountCodes(cartId, ['SAVE10']);
+await cartClient.updateNote(cartId, 'Gift message');
+await cartClient.updateBuyerIdentity(cartId, { email: 'user@example.com' });
+const existing = await cartClient.get(cartId);
+```
+
+Auto-throws `StorefrontError` with code `USER_ERROR` on validation failures.
+
+### AuthClient
+
+```typescript
+const authClient = new AuthClient(client);
+
+const { accessToken, expiresAt } = await authClient.login('user@example.com', 'pass');
+await authClient.logout(accessToken);
+const renewed = await authClient.renewToken(accessToken);
+const { accessToken, customer } = await authClient.register({ email, password, firstName });
+const customer = await authClient.getCustomer(accessToken);
+```
+
+### StorefrontError
+
+```typescript
+import { StorefrontError, ErrorCodes } from '@doswiftly/storefront-sdk';
+
+try {
+  await client.query(ProductQuery, { handle: 'missing' });
+} catch (err) {
+  if (err instanceof StorefrontError) {
+    err.code;           // 'GRAPHQL_ERROR' | 'NETWORK_ERROR' | 'TIMEOUT' | 'USER_ERROR' | ...
+    err.status;         // HTTP status (0 for network errors)
+    err.graphqlErrors;  // GraphQL-level errors
+    err.userErrors;     // Field-level validation errors
+    err.hasUserErrors;  // boolean
+    err.isNetworkError; // boolean
+    err.isTimeout;      // boolean
+  }
+}
+```
+
+### Format Utilities
+
+```typescript
+import {
+  formatPrice,
+  formatPriceRange,
+  formatAmount,
+  formatDate,
+  formatDateTime,
+  formatNumber,
+  formatPercentage,
+  getCurrencySymbol,
+  CURRENCY_SYMBOLS,
+  CURRENCY_LOCALES,
+} from '@doswiftly/storefront-sdk';
+
+formatPrice({ amount: '99.99', currencyCode: 'USD' }); // "$99.99"
+formatPriceRange(minPrice, maxPrice);                   // "$10.00 - $50.00"
+formatAmount('115.20', 'EUR');                          // "115,20 €"
+formatDate(new Date());                                // "Dec 9, 2025"
+formatPercentage(0.15);                                // "15%"
+```
+
+### HTML Sanitizer
+
+```typescript
+import { sanitizeHtml } from '@doswiftly/storefront-sdk';
+
+// Defense-in-depth: strips <script>, event handlers, javascript: URLs
+const safe = sanitizeHtml(userHtml);
+```
+
+### Connection Normalizer
+
+```typescript
+import { normalizeConnection } from '@doswiftly/storefront-sdk';
+
+// Relay connection → flat array
+const { items, pageInfo, totalCount } = normalizeConnection(data.products);
+```
+
+### Auth Cookie Config (Platform Contract)
+
+```typescript
+import { AUTH_COOKIE_NAME, AUTH_COOKIE_DEFAULTS } from '@doswiftly/storefront-sdk';
+
+// AUTH_COOKIE_NAME = 'customerAccessToken'
+// AUTH_COOKIE_DEFAULTS = { name, path, sameSite, httpOnly, secure, maxAge }
+```
+
+### Auth Cookie Handlers (API Route Factories)
+
+```typescript
+import { createSetTokenHandler, createClearTokenHandler } from '@doswiftly/storefront-sdk';
+
+// Next.js API route (2 lines):
+// app/api/auth/set-token/route.ts
+export const POST = createSetTokenHandler();
+
+// app/api/auth/clear-token/route.ts
+export const POST = createClearTokenHandler();
+```
+
+Uses pure Web API (Request/Response) — 0 deps, framework-agnostic.
+Security: origin validation, Content-Type check, CSRF via SameSite=Lax, httpOnly cookie.
+
+### Auth Token Client (Client-side)
+
+```typescript
+import { createAuthTokenClient } from '@doswiftly/storefront-sdk';
+
+const { setToken, clearToken } = createAuthTokenClient();
+await setToken(accessToken);  // POST /api/auth/set-token
+await clearToken();           // POST /api/auth/clear-token
+```
+
+### Route Matching
+
+```typescript
+import { matchesRoute } from '@doswiftly/storefront-sdk';
+
+// Supports exact and prefix matching
+matchesRoute('/account/orders', ['/account']); // true
+matchesRoute('/products', ['/account']);        // false
+```
+
+### Cache Strategies
+
+```typescript
+import { cacheLong, cacheShort, cacheNone, cachePrivate, cacheCustom } from '@doswiftly/storefront-sdk/cache';
+
+cacheLong()                              // 1h + 23h stale-while-revalidate
+cacheLong({ tags: ['product', slug] })   // with Next.js revalidation tags
+cacheShort()                             // 1s + 9s swr
+cacheNone()                              // no-store
+cachePrivate()                           // private, 1s + 9s swr
+cacheCustom({ maxAge: 300, swr: 600 })   // 5min + 10min swr
+```
+
+## React Adapter
+
+### Providers
+
+```tsx
+// Convenience (recommended)
+<StorefrontProvider config={{ apiUrl, shopSlug }} shopData={shop}>
+  {children}
+</StorefrontProvider>
+```
+
+`StorefrontProvider` creates Zustand store instances via `useRef` and provides them through React Context. This eliminates module-level singleton issues with Turbopack/bundler module duplication.
+
+### useAuth
+
+```typescript
+const {
+  login,        // (email, password) => Promise<LoginResult>
+  logout,       // () => Promise<LogoutResult>
+  renewToken,   // () => Promise<TokenRenewResult>
+  isLoggingIn, isLoggingOut, isRenewingToken, isLoading,
+  error,
+} = useAuth({
+  onSetToken: async (token) => { /* set httpOnly cookie via server route */ },
+  onClearToken: async () => { /* clear httpOnly cookie */ },
+});
+```
+
+### useCartManager
+
+```typescript
+const {
+  getCart,       // () => Promise<Cart | null>
+  addItem,       // (lines: CartLineInput[]) => Promise<Cart>
+  updateItem,    // (lines: CartLineUpdateInput[]) => Promise<Cart>
+  removeItem,    // (lineIds: string[]) => Promise<Cart>
+  updateDiscountCodes, updateNote, clearCart, getCartId,
+  isLoading, error,
+} = useCartManager();
+```
+
+Cart ID is persisted in a cookie (SSR/edge visible).
+
+### useHydrated
+
+```typescript
+import { useHydrated } from '@doswiftly/storefront-sdk/react';
+
+const isHydrated = useHydrated();
+// false during SSR and first client render, true after hydration
+// Use to guard browser-only state (localStorage, cookies, window)
+```
+
+### useDebouncedValue
+
+```typescript
+import { useDebouncedValue } from '@doswiftly/storefront-sdk/react';
+
+const debouncedQuery = useDebouncedValue(query, 300);
+```
+
+### createStoreContext
+
+```typescript
+import { createStoreContext } from '@doswiftly/storefront-sdk/react';
+import { createStore } from 'zustand/vanilla';
+
+// Define store factory + Context-based hooks (eliminates module-level singletons)
+const { Provider: CartProvider, useStore: useCartStore, useApi: useCartStoreApi } =
+  createStoreContext<CartState>('CartStore');
+
+// In layout:
+const cartStore = useRef(createCartStore()).current;
+<CartProvider store={cartStore}>{children}</CartProvider>
+
+// In components:
+const isOpen = useCartStore((s) => s.isOpen);
+const api = useCartStoreApi(); // for .getState() in callbacks
+```
+
+### Zustand Stores (Context-based)
+
+Stores use `createStore()` from `zustand/vanilla` + React Context pattern. All store hooks require `StorefrontProvider` wrapper.
+
+```typescript
+import { useAuthStore, useAuthHydrated, useCurrencyStore } from '@doswiftly/storefront-sdk/react';
+
+// Auth — state
+const { isAuthenticated, customer, accessToken } = useAuthStore();
+// Auth — with selector
+const isAuthenticated = useAuthStore(s => s.isAuthenticated);
+// Auth — persist hydration (replaces old isHydrated store field)
+const authHydrated = useAuthHydrated(); // true after localStorage rehydration
+
+// Currency
+const { currency, baseCurrency, supportedCurrencies, setCurrency, isLoaded } = useCurrencyStore();
+
+// For .getState() in callbacks (e.g. logout, renewToken)
+import { useAuthStoreApi, useCurrencyStoreApi } from '@doswiftly/storefront-sdk/react';
+const authStore = useAuthStoreApi();
+const token = authStore.getState().accessToken;
+```
+
+### Server-side
+
+```typescript
+import { getStorefrontClient } from '@doswiftly/storefront-sdk/react/server';
+
+// Server Component or Route Handler
+const client = getStorefrontClient({
+  apiUrl: process.env.API_URL!,
+  shopSlug: process.env.SHOP_SLUG!,
+});
+```
+
+## Template Integration
+
+Storefronts (Next.js templates) import SDK for **infrastructure** and own their **data-fetching layer**:
+
+```
+SDK provides:                    Template owns:
+├── Transport + Middleware       ├── codegen.ts + generated/graphql.ts
+├── CartClient + AuthClient      ├── lib/graphql/hooks.ts (React Query)
+├── Providers + Zustand stores   ├── lib/graphql/server.ts (React cache)
+├── Format utilities             ├── lib/graphql/fragments/
+├── sanitizeHtml                 ├── stores/ (UI state via createStoreContext)
+├── normalizeConnection          ├── hooks/ (use-auth, use-cart-actions, etc.)
+├── Auth handlers + token client ├── lib/auth/routes.ts (route config)
+├── useHydrated + useDebouncedValue
+├── createStoreContext           └── components/providers/
+├── AUTH_COOKIE_NAME + matchesRoute
+└── Cache strategies
+```
+
+Data-fetching hooks are generated locally via `@graphql-codegen/client-preset` (TypedDocumentString).
+
+## License
+
+MIT

package/dist/__tests__/unit/test-helpers.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared test helpers — mock fetch factory, mock client builder.
+ */
+/**
+ * Create a mock fetch that returns the specified GraphQL response.
+ */
+export declare function createMockFetch(responseData: unknown, options?: {
+    errors?: Array<{
+        message: string;
+    }>;
+    status?: number;
+    delay?: number;
+}): typeof globalThis.fetch;
+/**
+ * Create a mock fetch that tracks all calls and returns specified response.
+ */
+export declare function createSpyFetch(responseData: unknown, options?: {
+    errors?: Array<{
+        message: string;
+    }>;
+    status?: number;
+}): {
+    fetch: typeof globalThis.fetch;
+    calls: {
+        url: string;
+        init: RequestInit;
+    }[];
+};
+/**
+ * Create a mock fetch that fails with a network error.
+ */
+export declare function createNetworkErrorFetch(errorMessage?: string): typeof globalThis.fetch;
+/**
+ * Create a mock fetch that returns different responses on subsequent calls.
+ */
+export declare function createSequenceFetch(responses: Array<{
+    data?: unknown;
+    errors?: Array<{
+        message: string;
+    }>;
+    status?: number;
+}>): {
+    fetch: typeof globalThis.fetch;
+    callCount: () => number;
+};
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/__tests__/unit/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../src/__tests__/unit/test-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;GAEG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,OAAO,EACrB,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GACA,OAAO,UAAU,CAAC,KAAK,CAqBzB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,YAAY,EAAE,OAAO,EACrB,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;WAqB0B,OAAO,UAAU,CAAC,KAAK;;aAnBxB,MAAM;cAAQ,WAAW;;EAoBpD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,SAAiB,GAAG,OAAO,UAAU,CAAC,KAAK,CAI9F;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,KAAK,CAAC;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GACzF;IAAE,KAAK,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IAAC,SAAS,EAAE,MAAM,MAAM,CAAA;CAAE,CAiB7D"}

package/dist/__tests__/unit/test-helpers.js

@@ -0,0 +1,72 @@
+/**
+ * Shared test helpers — mock fetch factory, mock client builder.
+ */
+/**
+ * Create a mock fetch that returns the specified GraphQL response.
+ */
+export function createMockFetch(responseData, options) {
+    const { errors, status = 200, delay: delayMs } = options ?? {};
+    return async (_url, _init) => {
+        if (delayMs) {
+            await new Promise(r => setTimeout(r, delayMs));
+        }
+        // Check for abort signal
+        if (_init?.signal?.aborted) {
+            throw new DOMException('The operation was aborted', 'AbortError');
+        }
+        const body = { data: responseData };
+        if (errors)
+            body.errors = errors;
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    };
+}
+/**
+ * Create a mock fetch that tracks all calls and returns specified response.
+ */
+export function createSpyFetch(responseData, options) {
+    const calls = [];
+    const { errors, status = 200 } = options ?? {};
+    const fetchFn = async (url, init) => {
+        calls.push({ url: url.toString(), init: init });
+        if (init?.signal?.aborted) {
+            throw new DOMException('The operation was aborted', 'AbortError');
+        }
+        const body = { data: responseData };
+        if (errors)
+            body.errors = errors;
+        return new Response(JSON.stringify(body), {
+            status,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    };
+    return { fetch: fetchFn, calls };
+}
+/**
+ * Create a mock fetch that fails with a network error.
+ */
+export function createNetworkErrorFetch(errorMessage = 'fetch failed') {
+    return async () => {
+        throw new TypeError(errorMessage);
+    };
+}
+/**
+ * Create a mock fetch that returns different responses on subsequent calls.
+ */
+export function createSequenceFetch(responses) {
+    let index = 0;
+    const fetchFn = async (_url, _init) => {
+        const response = responses[Math.min(index, responses.length - 1)];
+        index++;
+        const body = { data: response.data ?? null };
+        if (response.errors)
+            body.errors = response.errors;
+        return new Response(JSON.stringify(body), {
+            status: response.status ?? 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    };
+    return { fetch: fetchFn, callCount: () => index };
+}

package/dist/core/auth/auth-client.d.ts

@@ -0,0 +1,46 @@
+/**
+ * AuthClient — plain async API for customer authentication (no React).
+ *
+ * Wraps StorefrontClient.mutate/query with typed auth operations.
+ * Auto-throws on userErrors via assertNoUserErrors.
+ *
+ * @example
+ * ```typescript
+ * const authClient = new AuthClient(storefrontClient);
+ *
+ * const result = await authClient.login('user@example.com', 'password');
+ * console.log(result.accessToken); // JWT token
+ *
+ * const customer = await authClient.getCustomer(result.accessToken);
+ * ```
+ */
+import type { StorefrontClient } from '../client/types';
+import type { AuthResult, Customer, CustomerCreateInput } from './types';
+export declare class AuthClient {
+    private readonly client;
+    constructor(client: StorefrontClient);
+    /**
+     * Login with email and password.
+     * Returns access token + expiry.
+     */
+    login(email: string, password: string): Promise<AuthResult>;
+    /**
+     * Logout — invalidate token on backend.
+     * Does not throw on failure (token may already be expired).
+     */
+    logout(token: string): Promise<void>;
+    /**
+     * Renew access token — extends expiry.
+     */
+    renewToken(token: string): Promise<AuthResult>;
+    /**
+     * Register new customer account.
+     * Returns access token + customer data.
+     */
+    register(input: CustomerCreateInput): Promise<AuthResult>;
+    /**
+     * Fetch customer data by access token.
+     */
+    getCustomer(accessToken: string): Promise<Customer | null>;
+}
+//# sourceMappingURL=auth-client.d.ts.map

package/dist/core/auth/auth-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-client.d.ts","sourceRoot":"","sources":["../../../src/core/auth/auth-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAUzE,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,gBAAgB;IAErD;;;OAGG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAiBjE;;;OAGG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa1C;;OAEG;IACG,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAiBpD;;;OAGG;IACG,QAAQ,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,CAAC;IAmB/D;;OAEG;IACG,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;CAOjE"}

package/dist/core/auth/auth-client.js

@@ -0,0 +1,82 @@
+/**
+ * AuthClient — plain async API for customer authentication (no React).
+ *
+ * Wraps StorefrontClient.mutate/query with typed auth operations.
+ * Auto-throws on userErrors via assertNoUserErrors.
+ *
+ * @example
+ * ```typescript
+ * const authClient = new AuthClient(storefrontClient);
+ *
+ * const result = await authClient.login('user@example.com', 'password');
+ * console.log(result.accessToken); // JWT token
+ *
+ * const customer = await authClient.getCustomer(result.accessToken);
+ * ```
+ */
+import { assertNoUserErrors } from '../helpers/assert-no-user-errors';
+import { CUSTOMER_LOGIN, CUSTOMER_LOGOUT, CUSTOMER_TOKEN_RENEW, CUSTOMER_CREATE, CUSTOMER_QUERY, } from '../operations/auth';
+export class AuthClient {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Login with email and password.
+     * Returns access token + expiry.
+     */
+    async login(email, password) {
+        const data = await this.client.mutate(CUSTOMER_LOGIN, { input: { email, password } });
+        assertNoUserErrors(data.customerAccessTokenCreate);
+        const token = data.customerAccessTokenCreate.customerAccessToken;
+        return {
+            accessToken: token.accessToken,
+            expiresAt: token.expiresAt,
+        };
+    }
+    /**
+     * Logout — invalidate token on backend.
+     * Does not throw on failure (token may already be expired).
+     */
+    async logout(token) {
+        try {
+            await this.client.mutate(CUSTOMER_LOGOUT, { customerAccessToken: token });
+        }
+        catch {
+            // Silently ignore — token may already be expired
+        }
+    }
+    /**
+     * Renew access token — extends expiry.
+     */
+    async renewToken(token) {
+        const data = await this.client.mutate(CUSTOMER_TOKEN_RENEW, { customerAccessToken: token });
+        assertNoUserErrors(data.customerAccessTokenRenew);
+        const renewed = data.customerAccessTokenRenew.customerAccessToken;
+        return {
+            accessToken: renewed.accessToken,
+            expiresAt: renewed.expiresAt,
+        };
+    }
+    /**
+     * Register new customer account.
+     * Returns access token + customer data.
+     */
+    async register(input) {
+        const data = await this.client.mutate(CUSTOMER_CREATE, { input });
+        assertNoUserErrors(data.customerCreate);
+        const token = data.customerCreate.customerAccessToken;
+        return {
+            accessToken: token.accessToken,
+            expiresAt: token.expiresAt,
+            customer: data.customerCreate.customer ?? undefined,
+        };
+    }
+    /**
+     * Fetch customer data by access token.
+     */
+    async getCustomer(accessToken) {
+        const data = await this.client.query(CUSTOMER_QUERY, { customerAccessToken: accessToken });
+        return data.customer;
+    }
+}