@doswiftly/storefront-sdk 4.4.0 → 4.7.1

package/src/react/providers/language-provider.tsx

@@ -1,34 +0,0 @@
-/**
- * LanguageProvider — initializes language store from Shop data.
- *
- * Thin wrapper that calls useLanguageStore.initialize() on mount
- * with the shop's language configuration from the server.
- *
- * NOTE: This only sets defaultLanguage and supportedLanguages.
- * The active `language` is set by the template's LanguageSyncProvider
- * which reads locale from the URL (via next-intl) and calls setLanguage().
- */
-
-'use client';
-
-import React, { useEffect } from 'react';
-import { useLanguageStore } from '../stores/store-context';
-import type { ShopConfig } from '../types/shop-config';
-
-export interface LanguageProviderProps {
-  children: React.ReactNode;
-  shopData: ShopConfig;
-}
-
-export function LanguageProvider({ children, shopData }: LanguageProviderProps) {
-  const initialize = useLanguageStore((s) => s.initialize);
-  const isLoaded = useLanguageStore((s) => s.isLoaded);
-
-  useEffect(() => {
-    if (!isLoaded) {
-      initialize(shopData);
-    }
-  }, [initialize, isLoaded, shopData]);
-
-  return <>{children}</>;
-}

package/src/react/providers/storefront-client-provider.tsx

@@ -1,107 +0,0 @@
-/**
- * StorefrontClientProvider — React context for SDK clients.
- *
- * Creates StorefrontClient + CartClient + AuthClient and provides them
- * to the component tree via React context.
- *
- * Registers default middleware pipeline: auth → currency → retry → timeout → errors.
- */
-
-'use client';
-
-import React, { createContext, useContext, useMemo } from 'react';
-import { createStorefrontClient } from '../../core/client/create-client';
-import { CartClient } from '../../core/cart/cart-client';
-import { AuthClient } from '../../core/auth/auth-client';
-import { authMiddleware } from '../../core/middleware/auth';
-import { currencyMiddleware } from '../../core/middleware/currency';
-import { languageMiddleware } from '../../core/middleware/language';
-import { botProtectionMiddleware, type BotProtectionTokenProvider } from '../../core/middleware/bot-protection';
-import { retryMiddleware } from '../../core/middleware/retry';
-import { timeoutMiddleware } from '../../core/middleware/timeout';
-import { errorMiddleware } from '../../core/middleware/errors';
-import { useAuthStoreApi, useCurrencyStoreApi, useLanguageStoreApi } from '../stores/store-context';
-import type { StorefrontClient, StorefrontClientConfig, Middleware } from '../../core/client/types';
-
-export interface StorefrontClientContextValue {
-  client: StorefrontClient;
-  cartClient: CartClient;
-  authClient: AuthClient;
-}
-
-const StorefrontClientContext = createContext<StorefrontClientContextValue | null>(null);
-
-export interface StorefrontClientProviderProps {
-  children: React.ReactNode;
-  config: StorefrontClientConfig;
-  /**
-   * Additional middleware to prepend to the default pipeline.
-   * Default pipeline: auth → currency → bot-protection → [custom] → retry → timeout → errors
-   */
-  middleware?: Middleware[];
-  /** Bot protection token provider (created by StorefrontProvider) */
-  botProtection?: BotProtectionTokenProvider | null;
-  /** Operations that require bot protection (from shop query) */
-  botProtectionOperations?: string[];
-}
-
-export function StorefrontClientProvider({
-  children,
-  config,
-  middleware: customMiddleware = [],
-  botProtection,
-  botProtectionOperations,
-}: StorefrontClientProviderProps) {
-  const authStore = useAuthStoreApi();
-  const currencyStore = useCurrencyStoreApi();
-  const languageStore = useLanguageStoreApi();
-
-  const value = useMemo(() => {
-    const client = createStorefrontClient({
-      ...config,
-      middleware: [
-        // Header middleware (runs first)
-        authMiddleware(() => authStore.getState().accessToken),
-        currencyMiddleware(() => currencyStore.getState().currency),
-        languageMiddleware(() => languageStore.getState().language),
-        // Bot protection (if configured)
-        ...(botProtection && botProtectionOperations?.length
-          ? [botProtectionMiddleware({
-              tokenProvider: botProtection,
-              protectedOperations: botProtectionOperations,
-            })]
-          : []),
-        // Custom middleware from props
-        ...customMiddleware,
-        // Infrastructure middleware (runs last)
-        retryMiddleware({ maxRetries: 2 }),
-        timeoutMiddleware({ timeout: 5000 }),
-        errorMiddleware(),
-      ],
-    });
-
-    const cartClient = new CartClient(client);
-    const authClient = new AuthClient(client);
-
-    return { client, cartClient, authClient };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [config.apiUrl, config.shopSlug, authStore, currencyStore, languageStore]);
-
-  return (
-    <StorefrontClientContext.Provider value={value}>
-      {children}
-    </StorefrontClientContext.Provider>
-  );
-}
-
-/**
- * Get StorefrontClient context value.
- * Must be used within StorefrontClientProvider.
- */
-export function useStorefrontClientContext(): StorefrontClientContextValue {
-  const ctx = useContext(StorefrontClientContext);
-  if (!ctx) {
-    throw new Error('useStorefrontClientContext must be used within StorefrontClientProvider');
-  }
-  return ctx;
-}

package/src/react/providers/storefront-provider.tsx

@@ -1,99 +0,0 @@
-/**
- * StorefrontProvider — convenience composition of all SDK providers.
- *
- * Creates store instances via useRef (stable across re-renders) and provides
- * them through React Context. Store Contexts wrap StorefrontClientProvider
- * so that middleware can access store state via useAuthStoreApi/useCurrencyStoreApi.
- *
- * Composition order: Store Contexts → StorefrontClientProvider → CurrencyProvider
- *
- * @example
- * ```tsx
- * // app/layout.tsx
- * import { StorefrontProvider } from '@doswiftly/storefront-sdk/react';
- *
- * export default async function RootLayout({ children }) {
- *   const shopData = await fetchShop();
- *   return (
- *     <StorefrontProvider
- *       config={{ apiUrl: '...', shopSlug: '...' }}
- *       shopData={shopData}
- *     >
- *       {children}
- *     </StorefrontProvider>
- *   );
- * }
- * ```
- */
-
-'use client';
-
-import React, { useRef } from 'react';
-import { AuthStoreContext, CurrencyStoreContext, LanguageStoreContext } from '../stores/store-context';
-import { createAuthStore } from '../stores/auth.store';
-import { createCurrencyStore } from '../stores/currency.store';
-import { createLanguageStore } from '../stores/language.store';
-import { StorefrontClientProvider, type StorefrontClientProviderProps } from './storefront-client-provider';
-import { CurrencyProvider, type CurrencyProviderProps } from './currency-provider';
-import { LanguageProvider } from './language-provider';
-import { createBotProtectionManager } from '../../core/bot-protection/create-manager';
-import { BotProtectionContext } from '../bot-protection/bot-protection-context';
-import { BotProtectionWidget } from '../bot-protection/bot-protection-widget';
-
-export interface StorefrontProviderProps extends StorefrontClientProviderProps {
-  shopData: CurrencyProviderProps['shopData'];
-  /**
-   * Server-side auth hint — set to `true` when httpOnly auth cookie exists.
-   * This allows the auth store to start with `isAuthenticated: true` on first render,
-   * eliminating the flash of "Sign In" while Zustand persist rehydrates from localStorage.
-   *
-   * Read from cookies() in a Server Component (layout.tsx) and pass here.
-   */
-  initialIsAuthenticated?: boolean;
-  /**
-   * Server-side language hint — pass the URL locale from next-intl params.
-   * Eliminates flash of wrong language on first render by initializing the
-   * language store with the correct value from the server.
-   */
-  initialLanguage?: string;
-}
-
-export function StorefrontProvider({
-  children,
-  config,
-  middleware,
-  shopData,
-  initialIsAuthenticated,
-  initialLanguage,
-}: StorefrontProviderProps) {
-  const authStoreRef = useRef(createAuthStore(initialIsAuthenticated));
-  const currencyStoreRef = useRef(createCurrencyStore());
-  const languageStoreRef = useRef(createLanguageStore(initialLanguage));
-  const botProtectionRef = useRef(
-    shopData.botProtection ? createBotProtectionManager(shopData.botProtection) : null,
-  );
-
-  return (
-    <AuthStoreContext.Provider value={authStoreRef.current}>
-      <CurrencyStoreContext.Provider value={currencyStoreRef.current}>
-        <LanguageStoreContext.Provider value={languageStoreRef.current}>
-          <StorefrontClientProvider
-            config={config}
-            middleware={middleware}
-            botProtection={botProtectionRef.current}
-            botProtectionOperations={shopData.botProtection?.protectedOperations}
-          >
-            <BotProtectionContext.Provider value={{ manager: botProtectionRef.current }}>
-              <CurrencyProvider shopData={shopData}>
-                <LanguageProvider shopData={shopData}>
-                  <BotProtectionWidget manager={botProtectionRef.current} />
-                  {children}
-                </LanguageProvider>
-              </CurrencyProvider>
-            </BotProtectionContext.Provider>
-          </StorefrontClientProvider>
-        </LanguageStoreContext.Provider>
-      </CurrencyStoreContext.Provider>
-    </AuthStoreContext.Provider>
-  );
-}

package/src/react/server/get-storefront-client.ts

@@ -1,60 +0,0 @@
-/**
- * Server-side StorefrontClient factory — for Server Components, API routes, etc.
- *
- * Creates a StorefrontClient with default middleware pipeline,
- * without requiring React context (no providers needed server-side).
- *
- * @example
- * ```typescript
- * // lib/graphql/server.ts
- * import { getStorefrontClient } from '@doswiftly/storefront-sdk/react/server';
- *
- * const client = getStorefrontClient({
- *   apiUrl: process.env.NEXT_PUBLIC_API_URL!,
- *   shopSlug: process.env.NEXT_PUBLIC_SHOP_SLUG!,
- * });
- *
- * export const fetchProduct = cache(async (handle: string) => {
- *   return client.query(ProductDocument, { handle });
- * });
- * ```
- */
-
-import { createStorefrontClient } from '../../core/client/create-client';
-import { retryMiddleware } from '../../core/middleware/retry';
-import { timeoutMiddleware } from '../../core/middleware/timeout';
-import { errorMiddleware } from '../../core/middleware/errors';
-import type { StorefrontClient, StorefrontClientConfig, Middleware } from '../../core/client/types';
-
-export interface ServerClientOptions extends Omit<StorefrontClientConfig, 'middleware'> {
-  /**
-   * Function that returns request-scoped headers (e.g. currency from cookie).
-   * Called once per client creation.
-   */
-  getHeaders?: () => Record<string, string> | Promise<Record<string, string>>;
-  /**
-   * Additional middleware (prepended to default pipeline).
-   */
-  middleware?: Middleware[];
-}
-
-/**
- * Create a StorefrontClient for server-side use.
- *
- * Includes default middleware: retry → timeout → errors.
- * Does NOT include auth/currency middleware (server has no Zustand stores).
- * Pass headers via config.defaultHeaders or getHeaders option.
- */
-export function getStorefrontClient(options: ServerClientOptions): StorefrontClient {
-  const { middleware: customMiddleware = [], ...config } = options;
-
-  return createStorefrontClient({
-    ...config,
-    middleware: [
-      ...customMiddleware,
-      retryMiddleware({ maxRetries: 2 }),
-      timeoutMiddleware({ timeout: 10000 }), // Server-side: 10s timeout
-      errorMiddleware(),
-    ],
-  });
-}

package/src/react/server/index.ts

@@ -1 +0,0 @@
-export { getStorefrontClient, type ServerClientOptions } from './get-storefront-client';

package/src/react/stores/auth.store.ts

@@ -1,112 +0,0 @@
-/**
- * Auth store factory — localStorage persistence via Zustand persist.
- *
- * Creates a vanilla Zustand store (not a React hook singleton).
- * Instance is created in StorefrontProvider via useRef and provided
- * through React Context — eliminates module duplication in Turbopack.
- *
- * httpOnly cookie is managed separately (for SSR/middleware).
- */
-
-import { createStore } from 'zustand/vanilla';
-import { persist } from 'zustand/middleware';
-
-export interface CustomerInfo {
-  id: string;
-  email: string;
-  firstName?: string;
-  lastName?: string;
-  phone?: string;
-}
-
-export interface AuthStore {
-  // State
-  customer: CustomerInfo | null;
-  accessToken: string | null;
-  isAuthenticated: boolean;
-  isLoading: boolean;
-
-  // Actions
-  setAuth: (customer: CustomerInfo, accessToken: string) => void;
-  clearAuth: () => void;
-  updateCustomer: (updates: Partial<CustomerInfo>) => void;
-  setLoading: (isLoading: boolean) => void;
-}
-
-export const createAuthStore = (initialIsAuthenticated = false) =>
-  createStore<AuthStore>()(
-    persist(
-      (set) => ({
-        customer: null,
-        accessToken: null,
-        isAuthenticated: initialIsAuthenticated,
-        isLoading: false,
-
-        setAuth: (customer, accessToken) =>
-          set({
-            customer,
-            accessToken,
-            isAuthenticated: true,
-          }),
-
-        clearAuth: () =>
-          set({
-            customer: null,
-            accessToken: null,
-            isAuthenticated: false,
-          }),
-
-        updateCustomer: (updates) =>
-          set((state) => ({
-            customer: state.customer
-              ? { ...state.customer, ...updates }
-              : null,
-          })),
-
-        setLoading: (isLoading) => set({ isLoading }),
-      }),
-      {
-        name: 'auth-storage',
-        version: 2, // Invalidate stale data from old module-level store era
-        partialize: (state) => ({
-          customer: state.customer,
-          accessToken: state.accessToken,
-          isAuthenticated: state.isAuthenticated,
-        }),
-        /**
-         * Custom merge — server cookie check (initialIsAuthenticated) is authoritative
-         * for isAuthenticated. localStorage provides supplementary data (customer, token).
-         *
-         * This prevents stale localStorage from overwriting the server-provided auth state.
-         */
-        merge: (persistedState, currentState) => {
-          const persisted = persistedState as Partial<AuthStore> | undefined;
-          if (!persisted) return currentState;
-
-          return {
-            ...currentState,
-            customer: persisted.customer ?? currentState.customer,
-            accessToken: persisted.accessToken ?? currentState.accessToken,
-            // Server cookie is the authority — never let stale localStorage override it
-            isAuthenticated: currentState.isAuthenticated,
-          } as AuthStore;
-        },
-        migrate: (persistedState, version) => {
-          if (version < 2) {
-            // Data from old module-level store may be unreliable (Turbopack duplication)
-            // Clear it — user will re-authenticate via cookie or login
-            return { customer: null, accessToken: null, isAuthenticated: false } as {
-              customer: CustomerInfo | null;
-              accessToken: string | null;
-              isAuthenticated: boolean;
-            };
-          }
-          return persistedState as {
-            customer: CustomerInfo | null;
-            accessToken: string | null;
-            isAuthenticated: boolean;
-          };
-        },
-      },
-    ),
-  );

package/src/react/stores/cart.context.ts

@@ -1,10 +0,0 @@
-'use client';
-
-import { createStoreContext } from '../helpers/create-store-context';
-import type { CartState } from './cart.store';
-
-export const {
-  Provider: CartProvider,
-  useStore: useCartStore,
-  useApi: useCartStoreApi,
-} = createStoreContext<CartState>('CartStore');

package/src/react/stores/cart.store.ts

@@ -1,254 +0,0 @@
-/**
- * Cart Store — DI-based cart state management with cookie persistence.
- *
- * SDK orchestrates cart lifecycle (init, mutations, error handling).
- * Template provides CartActions implementation via DI (getActions getter).
- * Cart ID persisted in cookie (SSR/edge visible) — follows currency store pattern.
- *
- * @example
- * ```typescript
- * import { createCartStore, type CartActions } from '@doswiftly/storefront-sdk/react';
- *
- * const actions: CartActions = {
- *   fetchCart: async (cartId) => api.getCart(cartId),
- *   createCart: async () => api.createCart().then(c => c.id),
- *   addLines: async (cartId, lines) => api.addLines(cartId, lines),
- *   updateLines: async (cartId, lines) => api.updateLines(cartId, lines),
- *   removeLines: async (cartId, lineIds) => api.removeLines(cartId, lineIds),
- * };
- *
- * const store = createCartStore({ getActions: () => actions });
- * ```
- */
-
-import { createStore } from 'zustand/vanilla';
-import type { CartLineInput, CartLineUpdateInput } from '../../core/cart/types';
-import { CART_COOKIE_NAME, CART_COOKIE_MAX_AGE } from '../../core/cart/cookie-config';
-import { getCookie, setCookie, deleteCookie } from '../cookies';
-
-// Re-export input types from core for convenience
-export type { CartLineInput, CartLineUpdateInput } from '../../core/cart/types';
-
-// ---------------------------------------------------------------------------
-// DI Contract
-// ---------------------------------------------------------------------------
-
-/** Minimal cart data returned by DI actions. */
-export interface CartData {
-  id: string;
-  totalQuantity: number;
-}
-
-/** DI contract — template implements these methods. */
-export interface CartActions {
-  /** Fetch cart by ID. Return null if cart expired/not found. */
-  fetchCart: (cartId: string) => Promise<CartData | null>;
-  /** Create new empty cart. Return new cart ID. */
-  createCart: () => Promise<string>;
-  /** Add line items. Return updated cart or throw. */
-  addLines: (cartId: string, lines: CartLineInput[]) => Promise<CartData>;
-  /** Update line quantities. Return updated cart or throw. */
-  updateLines: (cartId: string, lines: CartLineUpdateInput[]) => Promise<CartData>;
-  /** Remove line items. Return updated cart or throw. */
-  removeLines: (cartId: string, lineIds: string[]) => Promise<CartData>;
-}
-
-// ---------------------------------------------------------------------------
-// Config
-// ---------------------------------------------------------------------------
-
-/** Action names passed to mutation callbacks. */
-export type CartMutationAction = 'initCart' | 'addToCart' | 'updateQuantity' | 'removeFromCart';
-
-export interface CartStoreConfig {
-  /** Getter for DI actions — called on every operation (not captured). */
-  getActions: () => CartActions;
-  /** Called after successful mutation. */
-  onMutationSuccess?: (action: CartMutationAction, cart: CartData) => void;
-  /** Called on mutation error. */
-  onMutationError?: (action: CartMutationAction, error: unknown) => void;
-}
-
-// ---------------------------------------------------------------------------
-// State
-// ---------------------------------------------------------------------------
-
-export interface CartState {
-  // State
-  cartId: string | null;
-  isOpen: boolean;
-  isLoading: boolean;
-  error: unknown | null;
-
-  // UI Actions (pure state, no side effects)
-  openCart: () => void;
-  closeCart: () => void;
-  toggleCart: () => void;
-
-  // Orchestrated Actions (call DI via getActions)
-  initCart: () => Promise<void>;
-  addToCart: (lines: CartLineInput[]) => Promise<void>;
-  updateQuantity: (lines: CartLineUpdateInput[]) => Promise<void>;
-  removeFromCart: (lineIds: string[]) => Promise<void>;
-  clearCart: () => void;
-}
-
-// ---------------------------------------------------------------------------
-// Selectors
-// ---------------------------------------------------------------------------
-
-export const selectCartId = (state: CartState) => state.cartId;
-export const selectIsCartOpen = (state: CartState) => state.isOpen;
-export const selectCartIsLoading = (state: CartState) => state.isLoading;
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-export function createCartStore(config: CartStoreConfig) {
-  // Deduplication: shared Promise in closure (not in state)
-  let initPromise: Promise<void> | null = null;
-
-  // Read initial cartId from cookie (client-side only, returns null on server)
-  const initialCartId = getCookie(CART_COOKIE_NAME);
-
-  // Clean up old localStorage entry from pre-cookie era (v1 persist)
-  if (typeof localStorage !== 'undefined') {
-    try { localStorage.removeItem('cart-storage'); } catch { /* ignore */ }
-  }
-
-  async function performInit(
-    set: (partial: Partial<CartState> | ((state: CartState) => Partial<CartState>)) => void,
-    get: () => CartState,
-  ): Promise<void> {
-    const actions = config.getActions();
-    set({ isLoading: true, error: null });
-
-    try {
-      const currentCartId = get().cartId;
-
-      if (currentCartId) {
-        const cart = await actions.fetchCart(currentCartId);
-        if (cart) {
-          // Cart exists — keep current cartId
-          set({ isLoading: false });
-          return;
-        }
-        // Cart expired — fall through to create
-      }
-
-      // No cart or expired — create new
-      const newCartId = await actions.createCart();
-      set({ cartId: newCartId, isLoading: false, error: null });
-    } catch (error) {
-      set({ error, isLoading: false });
-      config.onMutationError?.('initCart', error);
-    }
-  }
-
-  const store = createStore<CartState>()(
-    (set, get) => ({
-      // State — initialCartId from cookie
-      cartId: initialCartId,
-      isOpen: false,
-      isLoading: false,
-      error: null,
-
-      // UI Actions
-      openCart: () => set({ isOpen: true }),
-      closeCart: () => set({ isOpen: false }),
-      toggleCart: () => set((state) => ({ isOpen: !state.isOpen })),
-
-      // Orchestrated: initCart (deduplicated)
-      initCart: async () => {
-        if (initPromise) return initPromise;
-        initPromise = performInit(set, get).finally(() => {
-          initPromise = null;
-        });
-        return initPromise;
-      },
-
-      // Orchestrated: addToCart (auto-init if no cartId)
-      addToCart: async (lines: CartLineInput[]) => {
-        const actions = config.getActions();
-        set({ isLoading: true, error: null });
-
-        try {
-          let cartId = get().cartId;
-          if (!cartId) {
-            await get().initCart();
-            cartId = get().cartId;
-          }
-          if (!cartId) {
-            throw new Error('Failed to initialize cart');
-          }
-
-          const cart = await actions.addLines(cartId, lines);
-          set({ isLoading: false, error: null });
-          config.onMutationSuccess?.('addToCart', cart);
-        } catch (error) {
-          set({ error, isLoading: false });
-          config.onMutationError?.('addToCart', error);
-        }
-      },
-
-      // Orchestrated: updateQuantity (error if no cartId)
-      updateQuantity: async (lines: CartLineUpdateInput[]) => {
-        const actions = config.getActions();
-        const cartId = get().cartId;
-
-        if (!cartId) {
-          const err = new Error('Cannot update quantity: no cart exists');
-          set({ error: err });
-          config.onMutationError?.('updateQuantity', err);
-          return;
-        }
-
-        set({ isLoading: true, error: null });
-        try {
-          const cart = await actions.updateLines(cartId, lines);
-          set({ isLoading: false, error: null });
-          config.onMutationSuccess?.('updateQuantity', cart);
-        } catch (error) {
-          set({ error, isLoading: false });
-          config.onMutationError?.('updateQuantity', error);
-        }
-      },
-
-      // Orchestrated: removeFromCart (silent return if no cartId)
-      removeFromCart: async (lineIds: string[]) => {
-        const cartId = get().cartId;
-        if (!cartId) return;
-
-        const actions = config.getActions();
-        set({ isLoading: true, error: null });
-        try {
-          const cart = await actions.removeLines(cartId, lineIds);
-          set({ isLoading: false, error: null });
-          config.onMutationSuccess?.('removeFromCart', cart);
-        } catch (error) {
-          set({ error, isLoading: false });
-          config.onMutationError?.('removeFromCart', error);
-        }
-      },
-
-      // clearCart — reset all state
-      clearCart: () => {
-        set({ cartId: null, isOpen: false, isLoading: false, error: null });
-      },
-    }),
-  );
-
-  // Sync cartId changes to cookie (like currency store pattern)
-  store.subscribe((state, prevState) => {
-    if (state.cartId !== prevState.cartId) {
-      if (state.cartId) {
-        setCookie(CART_COOKIE_NAME, state.cartId, { maxAge: CART_COOKIE_MAX_AGE });
-      } else {
-        deleteCookie(CART_COOKIE_NAME);
-      }
-    }
-  });
-
-  return store;
-}