@instockng/api-client 1.0.0 → 1.0.2

package/src/hooks/public/carts.ts

@@ -1,298 +0,0 @@
-/**
- * Type-safe RPC hooks for cart operations
- *
- * These hooks use Hono RPC client with types directly from the backend,
- * providing end-to-end type safety without code generation.
- */
-
-import { useMutation, useQueryClient, UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
-import { useQueryUnwrapped } from '../use-query-unwrapped';
-import { queryKeys } from '../../utils/query-keys';
-import {
-  fetchCart,
-  updateCart,
-  createCart,
-  addCartItem,
-  updateCartItem,
-  removeCartItem,
-  applyDiscount,
-  removeDiscount,
-  checkoutCart,
-} from '../../fetchers/carts';
-
-/**
- * Hook to get cart by ID using RPC
- *
- * @param cartId - Cart UUID
- * @param options - React Query options
- *
- * @example
- * ```tsx
- * const { data: cart, isLoading } = useGetCart('cart-123');
- * console.log(cart?.cart.brand.name); // Fully typed!
- * ```
- */
-export function useGetCart(
-  cartId: string,
-  options?: Omit<UseQueryOptions<Awaited<ReturnType<typeof fetchCart>>, Error>, 'queryKey' | 'queryFn'>
-) {
-  return useQueryUnwrapped({
-    queryKey: queryKeys.public.carts.detail(cartId),
-    queryFn: () => fetchCart(cartId),
-    ...options,
-  });
-}
-
-/**
- * Hook to update cart using RPC
- *
- * @param cartId - Cart UUID
- * @param options - React Query mutation options
- *
- * @example
- * ```tsx
- * const updateCart = useUpdateCart('cart-123');
- * updateCart.mutate({
- *   customerEmail: 'user@example.com',
- *   deliveryZoneId: 'zone-123'
- * });
- * ```
- */
-export function useUpdateCart(
-  cartId: string,
-  options?: UseMutationOptions<
-    Awaited<ReturnType<typeof updateCart>>,
-    Error,
-    Parameters<typeof updateCart>[1]
-  >
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (data) => updateCart(cartId, data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: queryKeys.public.carts.detail(cartId) });
-    },
-    ...options,
-  });
-}
-
-/**
- * Hook to create a new cart using RPC
- *
- * @param options - React Query mutation options
- *
- * @example
- * ```tsx
- * const createCart = useCreateCart();
- * createCart.mutate('my-brand');
- * ```
- */
-export function useCreateCart(
-  options?: UseMutationOptions<
-    Awaited<ReturnType<typeof createCart>>,
-    Error,
-    string
-  >
-) {
-  return useMutation({
-    mutationFn: (brandSlug: string) => createCart(brandSlug),
-    ...options,
-  });
-}
-
-/**
- * Hook to apply discount code to cart using RPC
- *
- * @param cartId - Cart UUID
- * @param options - React Query mutation options
- *
- * @example
- * ```tsx
- * const applyDiscount = useApplyDiscount('cart-123');
- * applyDiscount.mutate({ code: 'SAVE10' });
- * ```
- */
-export function useApplyDiscount(
-  cartId: string,
-  options?: UseMutationOptions<
-    Awaited<ReturnType<typeof applyDiscount>>,
-    Error,
-    { code: string }
-  >
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (data) => applyDiscount(cartId, data.code),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: queryKeys.public.carts.detail(cartId) });
-    },
-    ...options,
-  });
-}
-
-/**
- * Hook to remove discount code from cart using RPC
- *
- * @param cartId - Cart UUID
- * @param options - React Query mutation options
- *
- * @example
- * ```tsx
- * const removeDiscount = useRemoveDiscount('cart-123');
- * removeDiscount.mutate();
- * ```
- */
-export function useRemoveDiscount(
-  cartId: string,
-  options?: UseMutationOptions<
-    Awaited<ReturnType<typeof removeDiscount>>,
-    Error,
-    void
-  >
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: () => removeDiscount(cartId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: queryKeys.public.carts.detail(cartId) });
-    },
-    ...options,
-  });
-}
-
-/**
- * Hook to add item to cart using RPC
- *
- * @param cartId - Cart UUID
- * @param options - React Query mutation options
- *
- * @example
- * ```tsx
- * const addItem = useAddCartItem('cart-123');
- * addItem.mutate({ sku: 'PROD-001', quantity: 2 });
- * ```
- */
-export function useAddCartItem(
-  cartId: string,
-  options?: UseMutationOptions<
-    Awaited<ReturnType<typeof addCartItem>>,
-    Error,
-    { sku: string; quantity: number }
-  >
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (data) => addCartItem(cartId, data.sku, data.quantity),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: queryKeys.public.carts.detail(cartId) });
-    },
-    ...options,
-  });
-}
-
-/**
- * Hook to update cart item quantity using RPC
- *
- * @param cartId - Cart UUID
- * @param options - React Query mutation options
- *
- * @example
- * ```tsx
- * const updateItem = useUpdateCartItem('cart-123');
- * updateItem.mutate({ itemId: 'item-456', quantity: 3 });
- * ```
- */
-export function useUpdateCartItem(
-  cartId: string,
-  options?: UseMutationOptions<
-    Awaited<ReturnType<typeof updateCartItem>>,
-    Error,
-    { itemId: string; quantity: number }
-  >
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: ({ itemId, quantity }) => updateCartItem(cartId, itemId, quantity),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: queryKeys.public.carts.detail(cartId) });
-    },
-    ...options,
-  });
-}
-
-/**
- * Hook to remove item from cart using RPC
- *
- * @param cartId - Cart UUID
- * @param options - React Query mutation options
- *
- * @example
- * ```tsx
- * const removeItem = useRemoveCartItem('cart-123');
- * removeItem.mutate('item-456'); // Pass itemId in mutate call
- * ```
- */
-export function useRemoveCartItem(
-  cartId: string,
-  options?: UseMutationOptions<
-    Awaited<ReturnType<typeof removeCartItem>>,
-    Error,
-    string
-  >
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (itemId: string) => removeCartItem(cartId, itemId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: queryKeys.public.carts.detail(cartId) });
-    },
-    ...options,
-  });
-}
-
-/**
- * Hook to checkout a cart and create an order using RPC
- *
- * @param cartId - Cart UUID
- * @param options - React Query mutation options
- *
- * @example
- * ```tsx
- * const checkout = useCheckoutCart('cart-123');
- * checkout.mutate({
- *   firstName: 'John',
- *   lastName: 'Doe',
- *   email: 'john@example.com',
- *   phone: '+1234567890',
- *   address: '123 Main St',
- *   city: 'New York',
- *   deliveryZoneId: 'zone-123',
- *   paymentMethod: 'cod'
- * });
- * ```
- */
-export function useCheckoutCart(
-  cartId: string,
-  options?: UseMutationOptions<
-    Awaited<ReturnType<typeof checkoutCart>>,
-    Error,
-    Parameters<typeof checkoutCart>[1]
-  >
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (data) => checkoutCart(cartId, data),
-    onSuccess: () => {
-      // Invalidate cart query since it's now converted to an order
-      queryClient.invalidateQueries({ queryKey: queryKeys.public.carts.detail(cartId) });
-    },
-    ...options,
-  });
-}

package/src/hooks/use-query-unwrapped.ts

@@ -1,30 +0,0 @@
-import { useQuery, type UseQueryOptions, type UseQueryResult } from '@tanstack/react-query';
-
-/**
- * Wrapper around useQuery that narrows the data type to exclude error responses
- *
- * Since our hooks throw on HTTP errors (via `if (!res.ok) throw new Error(...)`),
- * the data will never actually be an error response at runtime. This wrapper
- * tells TypeScript that truth.
- *
- * @example
- * ```ts
- * // Instead of:
- * return useQuery({ ... })  // Returns UseQueryResult<Data | { error: ... }, Error>
- *
- * // Use:
- * return useQueryUnwrapped({ ... })  // Returns UseQueryResult<Data, Error>
- * ```
- */
-export function useQueryUnwrapped<
-  TData,
-  TError = Error,
-  TQueryKey extends readonly unknown[] = readonly unknown[]
->(
-  options: UseQueryOptions<TData, TError, TData, TQueryKey>
-): UseQueryResult<Exclude<TData, { error: any }>, TError> {
-  const result = useQuery(options);
-
-  // Cast the data to exclude error types since we throw on errors
-  return result as UseQueryResult<Exclude<TData, { error: any }>, TError>;
-}

package/src/hooks/useApiConfig.ts

@@ -1,22 +0,0 @@
-/**
- * Hook to access API configuration from context
- */
-
-import { useApiClientContext } from '../provider';
-
-export interface ApiConfig {
-  baseURL: string;
-  authToken: string;
-}
-
-/**
- * Get API configuration from context
- */
-export function useApiConfig(): ApiConfig {
-  const { baseURL, authToken } = useApiClientContext();
-
-  return {
-    baseURL,
-    authToken: authToken || '',
-  };
-}

package/src/provider.tsx

@@ -1,89 +0,0 @@
-/**
- * React context provider for API client configuration
- */
-
-import { createContext, useContext, useEffect, ReactNode, useMemo } from 'react';
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { AxiosError } from 'axios';
-import { initializeApiClient, ApiClientConfig } from './client';
-
-interface ApiClientContextValue {
-  baseURL: string;
-  authToken?: string;
-}
-
-const ApiClientContext = createContext<ApiClientContextValue | null>(null);
-
-export interface ApiClientProviderProps {
-  children: ReactNode;
-  baseURL?: string;
-  authToken?: string;
-  onError?: (error: AxiosError) => void;
-  queryClient?: QueryClient;
-}
-
-/**
- * Provider component that initializes the API client and React Query
- *
- * @example
- * ```tsx
- * <ApiClientProvider>
- *   <App />
- * </ApiClientProvider>
- * ```
- */
-export function ApiClientProvider({
-  children,
-  baseURL = 'https://oms-api.instock.ng',
-  authToken,
-  onError,
-  queryClient: externalQueryClient
-}: ApiClientProviderProps) {
-  // Initialize client synchronously on first render
-  const config: ApiClientConfig = {
-    baseURL,
-    onError,
-  };
-
-  initializeApiClient(config);
-
-  // Update client when config changes
-  useEffect(() => {
-    initializeApiClient(config);
-  }, [baseURL, onError]);
-
-  // Create a default query client if one isn't provided
-  const queryClient = useMemo(
-    () =>
-      externalQueryClient ||
-      new QueryClient({
-        defaultOptions: {
-          queries: {
-            retry: 1,
-            refetchOnWindowFocus: false,
-            staleTime: 5000,
-          },
-        },
-      }),
-    [externalQueryClient]
-  );
-
-  return (
-    <QueryClientProvider client={queryClient}>
-      <ApiClientContext.Provider value={{ baseURL, authToken }}>
-        {children}
-      </ApiClientContext.Provider>
-    </QueryClientProvider>
-  );
-}
-
-/**
- * Hook to access API client context
- */
-export function useApiClientContext() {
-  const context = useContext(ApiClientContext);
-  if (!context) {
-    throw new Error('useApiClientContext must be used within ApiClientProvider');
-  }
-  return context;
-}

package/src/rpc-client.ts

@@ -1,106 +0,0 @@
-/**
- * Hono RPC client for type-safe API access
- *
- * This creates typed RPC clients that import backend types directly.
- * The clients are used by RPC hooks to provide end-to-end type safety.
- */
-
-import { hc } from 'hono/client';
-import type {
-  CartsRPC,
-  OrdersRPC,
-  ProductsRPC,
-  DeliveryZonesRPC,
-  AdminOrdersRPC,
-  AdminBrandsRPC,
-  AdminProductsRPC,
-  AdminVariantsRPC,
-  AdminWarehousesRPC,
-  AdminInventoryRPC,
-  AdminCustomersRPC,
-  AdminStatsRPC,
-  AdminAbandonedCartsRPC,
-  AdminDiscountCodesRPC,
-  AdminDeliveryZonesRPC,
-} from 'backend';
-
-/**
- * Create typed RPC clients for all public endpoints
- *
- * @param baseURL - Base URL for API requests (e.g., 'https://api.example.com')
- * @returns Object with typed Hono RPC clients for each endpoint
- *
- * @example
- * ```ts
- * const clients = createRpcClients('https://api.example.com');
- * const res = await clients.carts[':id'].$get({ param: { id: 'cart-123' } });
- * const data = await res.json(); // Fully typed!
- * ```
- */
-export function createRpcClients(baseURL: string) {
-  const fullBaseUrl = `${baseURL}/v1`;
-
-  return {
-    carts: hc<CartsRPC>(`${fullBaseUrl}/carts`),
-    orders: hc<OrdersRPC>(`${fullBaseUrl}/orders`),
-    products: hc<ProductsRPC>(`${fullBaseUrl}/products`),
-    deliveryZones: hc<DeliveryZonesRPC>(`${fullBaseUrl}/delivery-zones`),
-  };
-}
-
-/**
- * Create typed RPC clients for all admin endpoints
- *
- * @param baseURL - Base URL for API requests (e.g., 'https://api.example.com')
- * @returns Object with typed Hono RPC clients for each admin endpoint
- *
- * @example
- * ```ts
- * const clients = createAdminRpcClients('https://api.example.com');
- * const res = await clients.orders.index.$get({
- *   headers: { Authorization: `Bearer ${token}` }
- * });
- * const data = await res.json(); // Fully typed!
- * ```
- */
-export function createAdminRpcClients(baseURL: string) {
-  const fullBaseUrl = `${baseURL}/v1/admin`;
-
-  return {
-    orders: hc<AdminOrdersRPC>(`${fullBaseUrl}/orders`),
-    brands: hc<AdminBrandsRPC>(`${fullBaseUrl}/brands`),
-    products: hc<AdminProductsRPC>(`${fullBaseUrl}/products`),
-    variants: hc<AdminVariantsRPC>(`${fullBaseUrl}/variants`),
-    warehouses: hc<AdminWarehousesRPC>(`${fullBaseUrl}/warehouses`),
-    inventory: hc<AdminInventoryRPC>(`${fullBaseUrl}/inventory`),
-    customers: hc<AdminCustomersRPC>(`${fullBaseUrl}/customers`),
-    stats: hc<AdminStatsRPC>(`${fullBaseUrl}/stats`),
-    abandonedCarts: hc<AdminAbandonedCartsRPC>(`${fullBaseUrl}/abandoned-carts`),
-    discountCodes: hc<AdminDiscountCodesRPC>(`${fullBaseUrl}/discount-codes`),
-    deliveryZones: hc<AdminDeliveryZonesRPC>(`${fullBaseUrl}/delivery-zones`),
-  };
-}
-
-/**
- * Helper to create auth headers for admin RPC requests
- *
- * @param authToken - Clerk authentication token
- * @returns Headers object with Authorization header
- *
- * @example
- * ```ts
- * const res = await client.brands.index.$get(
- *   {},
- *   authHeaders(token)
- * );
- * ```
- */
-export function authHeaders(authToken: string) {
-  return { headers: { Authorization: `Bearer ${authToken}` } };
-}
-
-/**
- * Type of the RPC clients for use in hooks
- */
-export type RpcClients = ReturnType<typeof createRpcClients>;
-export type AdminRpcClients = ReturnType<typeof createAdminRpcClients>;

package/src/utils/query-keys.ts

@@ -1,121 +0,0 @@
-/**
- * Query key factories for React Query
- *
- * This provides a centralized way to manage query keys,
- * making it easier to invalidate and refetch queries.
- *
- * @see https://tkdodo.eu/blog/effective-react-query-keys
- */
-
-export const queryKeys = {
-  // Public API keys (RPC is now the default)
-  public: {
-    all: ['public'] as const,
-
-    carts: {
-      all: ['public', 'carts'] as const,
-      detail: (id: string) => ['public', 'carts', id] as const,
-    },
-
-    orders: {
-      all: ['public', 'orders'] as const,
-      detail: (id: string, token: string) => ['public', 'orders', id, token] as const,
-    },
-
-    products: {
-      all: ['public', 'products'] as const,
-      list: (brandId: string) => ['public', 'products', brandId] as const,
-      detail: (productId: string) => ['public', 'products', productId] as const,
-    },
-
-    deliveryZones: {
-      all: ['public', 'delivery-zones'] as const,
-      list: (brandId?: string) => ['public', 'delivery-zones', brandId] as const,
-    },
-  },
-
-  // Admin API keys (RPC is now the default)
-  admin: {
-    all: ['admin'] as const,
-
-    orders: {
-      all: ['admin', 'orders'] as const,
-      list: () => ['admin', 'orders', 'list'] as const,
-      detail: (id: string) => ['admin', 'orders', id] as const,
-    },
-
-    brands: {
-      all: ['admin', 'brands'] as const,
-      list: () => ['admin', 'brands', 'list'] as const,
-      detail: (id: string) => ['admin', 'brands', id] as const,
-    },
-
-    products: {
-      all: ['admin', 'products'] as const,
-      list: (brandId?: string) => ['admin', 'products', 'list', brandId] as const,
-      detail: (id: string) => ['admin', 'products', id] as const,
-    },
-
-    variants: {
-      all: ['admin', 'variants'] as const,
-      list: () => ['admin', 'variants', 'list'] as const,
-      detail: (id: string) => ['admin', 'variants', id] as const,
-      search: (params?: any) => ['admin', 'variants', 'search', params] as const,
-      byProduct: (productId: string) => ['admin', 'variants', 'product', productId] as const,
-      inventory: (id: string) => ['admin', 'variants', id, 'inventory'] as const,
-    },
-
-    warehouses: {
-      all: ['admin', 'warehouses'] as const,
-      list: () => ['admin', 'warehouses', 'list'] as const,
-      detail: (id: string) => ['admin', 'warehouses', id] as const,
-      inventory: (id: string) => ['admin', 'warehouses', id, 'inventory'] as const,
-    },
-
-    inventory: {
-      all: ['admin', 'inventory'] as const,
-      list: (params?: any) => ['admin', 'inventory', 'list', params] as const,
-      transactions: (params?: any) => ['admin', 'inventory', 'transactions', params] as const,
-      lowStock: (brandId?: string) => ['admin', 'inventory', 'low-stock', brandId] as const,
-    },
-
-    customers: {
-      all: ['admin', 'customers'] as const,
-      history: (phone: string) => ['admin', 'customers', 'history', phone] as const,
-    },
-
-    stats: {
-      all: ['admin', 'stats'] as const,
-      overview: (brandId?: string) => ['admin', 'stats', 'overview', brandId] as const,
-    },
-
-    abandonedCarts: {
-      all: ['admin', 'abandoned-carts'] as const,
-      list: (params?: any) => ['admin', 'abandoned-carts', 'list', params] as const,
-      detail: (id: string) => ['admin', 'abandoned-carts', id] as const,
-      stats: (brandId?: string) => ['admin', 'abandoned-carts', 'stats', brandId] as const,
-    },
-
-    discountCodes: {
-      all: ['admin', 'discount-codes'] as const,
-      list: (params?: any) => ['admin', 'discount-codes', 'list', params] as const,
-      detail: (id: string) => ['admin', 'discount-codes', id] as const,
-      analytics: (id: string) => ['admin', 'discount-codes', id, 'analytics'] as const,
-      overviewStats: () => ['admin', 'discount-codes', 'stats', 'overview'] as const,
-    },
-
-    deliveryZones: {
-      all: ['admin', 'delivery-zones'] as const,
-      states: {
-        all: ['admin', 'delivery-zones', 'states'] as const,
-        list: () => ['admin', 'delivery-zones', 'states', 'list'] as const,
-        detail: (id: string) => ['admin', 'delivery-zones', 'states', id] as const,
-      },
-      zones: {
-        all: ['admin', 'delivery-zones', 'zones'] as const,
-        list: (params?: any) => ['admin', 'delivery-zones', 'zones', 'list', params] as const,
-        detail: (id: string) => ['admin', 'delivery-zones', 'zones', id] as const,
-      },
-    },
-  },
-};