@instockng/api-client 1.0.0 → 1.0.2

package/dist/rpc-client.js

@@ -0,0 +1,78 @@
+/**
+ * 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';
+/**
+ * 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) {
+    const fullBaseUrl = `${baseURL}/v1`;
+    return {
+        carts: hc(`${fullBaseUrl}/carts`),
+        orders: hc(`${fullBaseUrl}/orders`),
+        products: hc(`${fullBaseUrl}/products`),
+        deliveryZones: hc(`${fullBaseUrl}/delivery-zones`),
+        brands: hc(`${fullBaseUrl}/brands`),
+    };
+}
+/**
+ * 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) {
+    const fullBaseUrl = `${baseURL}/v1/admin`;
+    return {
+        orders: hc(`${fullBaseUrl}/orders`),
+        brands: hc(`${fullBaseUrl}/brands`),
+        products: hc(`${fullBaseUrl}/products`),
+        variants: hc(`${fullBaseUrl}/variants`),
+        warehouses: hc(`${fullBaseUrl}/warehouses`),
+        inventory: hc(`${fullBaseUrl}/inventory`),
+        customers: hc(`${fullBaseUrl}/customers`),
+        stats: hc(`${fullBaseUrl}/stats`),
+        abandonedCarts: hc(`${fullBaseUrl}/abandoned-carts`),
+        discountCodes: hc(`${fullBaseUrl}/discount-codes`),
+        deliveryZones: hc(`${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) {
+    return { headers: { Authorization: `Bearer ${authToken}` } };
+}

package/{src/rpc-types.ts → dist/rpc-types.d.ts}

@@ -4,118 +4,73 @@
  * The hooks already have proper Hono RPC type inference built-in.
  * We extract the data types from UseQueryResult<T, E> to get the actual response types.
  */
-
 import type { UseQueryResult } from '@tanstack/react-query';
-
-// Helper to extract data type from UseQueryResult
-// Note: This includes error response types in the union, which is technically correct
-// since Hono RPC types include all possible HTTP responses. The hooks will throw on errors
-// at runtime, but TypeScript doesn't know that. Consumers should use type guards like:
-// `if (data && 'propertyName' in data) { ... }` to narrow the type.
-type QueryData<T> = T extends UseQueryResult<infer D, any>
-  ? NonNullable<D>
-  : never;
-
-// Import all hooks for type extraction
-import type {
-  useGetCart,
-  useGetOrder,
-  useGetProducts,
-  useGetDeliveryZones,
-  useCheckoutCart,
-} from './hooks/public';
-
-import type {
-  useListOrders,
-  useGetOrder as useGetAdminOrder,
-  useListBrands,
-  useListProducts,
-  useGetProduct,
-  useSearchVariants,
-  useListWarehouses,
-  useListInventory,
-  useGetCustomerHistory,
-  useGetStats,
-  useListAbandonedCarts,
-  useListDiscountCodes,
-  useGetDiscountCode,
-  useGetDiscountCodeAnalytics,
-  useListDeliveryZones as useListAdminDeliveryZones,
-  useListStates,
-} from './hooks/admin';
-
-// ============================================================================
-// Admin API Response Types
-// ============================================================================
-
+type QueryData<T> = T extends UseQueryResult<infer D, any> ? NonNullable<D> : never;
+import type { useGetCart, useGetOrder, useGetProducts, useGetDeliveryZones } from './hooks/public';
+import type { useListOrders, useGetOrder as useGetAdminOrder, useListBrands, useListProducts, useGetProduct, useSearchVariants, useListWarehouses, useListInventory, useGetCustomerHistory, useGetStats, useListAbandonedCarts, useListDiscountCodes, useGetDiscountCode, useGetDiscountCodeAnalytics, useListDeliveryZones as useListAdminDeliveryZones, useListStates } from './hooks/admin';
 export type AdminBrandsResponse = QueryData<ReturnType<typeof useListBrands>>;
 export type Brand = AdminBrandsResponse extends Array<infer Item> ? Item : never;
-
 export type AdminProductsResponse = QueryData<ReturnType<typeof useListProducts>>;
 export type AdminProduct = AdminProductsResponse extends Array<infer Item> ? Item : never;
-
 export type AdminProductFull = QueryData<ReturnType<typeof useGetProduct>>;
-
 export type AdminOrdersResponse = QueryData<ReturnType<typeof useListOrders>>;
-export type AdminOrder = AdminOrdersResponse extends { data: Array<infer Item> } ? Item : never;
-
+export type AdminOrder = AdminOrdersResponse extends {
+    data: Array<infer Item>;
+} ? Item : never;
 export type AdminOrderFull = QueryData<ReturnType<typeof useGetAdminOrder>>;
-
 export type AdminVariantsResponse = QueryData<ReturnType<typeof useSearchVariants>>;
 export type Variant = AdminVariantsResponse extends Array<infer Item> ? Item : never;
-
 export type AdminWarehousesResponse = QueryData<ReturnType<typeof useListWarehouses>>;
 export type Warehouse = AdminWarehousesResponse extends Array<infer Item> ? Item : never;
-
 export type AdminInventoryResponse = QueryData<ReturnType<typeof useListInventory>>;
 export type InventoryItem = AdminInventoryResponse extends Array<infer Item> ? Item : never;
-
 export type AdminCustomerHistoryResponse = QueryData<ReturnType<typeof useGetCustomerHistory>>;
-export type Customer = AdminCustomerHistoryResponse extends { customer: infer C } ? C : never;
-export type CustomerOrder = AdminCustomerHistoryResponse extends { orders: Array<infer Item> } ? Item : never;
-
+export type Customer = AdminCustomerHistoryResponse extends {
+    customer: infer C;
+} ? C : never;
+export type CustomerOrder = AdminCustomerHistoryResponse extends {
+    orders: Array<infer Item>;
+} ? Item : never;
 export type AdminStatsResponse = QueryData<ReturnType<typeof useGetStats>>;
-export type AdminStatsOverview = AdminStatsResponse extends { overview: infer O } ? O : never;
-export type RecentOrder = AdminStatsResponse extends { recentOrders: Array<infer Item> } ? Item : never;
-
+export type AdminStatsOverview = AdminStatsResponse extends {
+    overview: infer O;
+} ? O : never;
+export type RecentOrder = AdminStatsResponse extends {
+    recentOrders: Array<infer Item>;
+} ? Item : never;
 export type AdminAbandonedCartsResponse = QueryData<ReturnType<typeof useListAbandonedCarts>>;
-export type AbandonedCart = AdminAbandonedCartsResponse extends { carts: Array<infer Item> } ? Item : never;
-
+export type AbandonedCart = AdminAbandonedCartsResponse extends {
+    carts: Array<infer Item>;
+} ? Item : never;
 export type AdminDiscountCodesResponse = QueryData<ReturnType<typeof useListDiscountCodes>>;
-export type DiscountCode = AdminDiscountCodesResponse extends { data: Array<infer Item> } ? Item : never;
-
+export type DiscountCode = AdminDiscountCodesResponse extends {
+    data: Array<infer Item>;
+} ? Item : never;
 export type DiscountCodeFull = QueryData<ReturnType<typeof useGetDiscountCode>>;
-
 export type DiscountCodeAnalytics = QueryData<ReturnType<typeof useGetDiscountCodeAnalytics>>;
-
-// Admin Delivery Zones - returns flat array of zones
 export type AdminDeliveryZonesResponse = QueryData<ReturnType<typeof useListAdminDeliveryZones>>;
-export type AdminDeliveryZone = AdminDeliveryZonesResponse extends readonly (infer Item)[] ? Item :
-  AdminDeliveryZonesResponse extends (infer Item)[] ? Item : never;
-
-// Admin States - returns array of states with nested deliveryZones
+export type AdminDeliveryZone = AdminDeliveryZonesResponse extends readonly (infer Item)[] ? Item : AdminDeliveryZonesResponse extends (infer Item)[] ? Item : never;
 export type AdminStatesResponse = QueryData<ReturnType<typeof useListStates>>;
 export type AdminStateWithZones = AdminStatesResponse extends Array<infer Item> ? Item : never;
 export type State = Omit<AdminStateWithZones, 'deliveryZones'>;
 export type AdminState = State;
-
-// ============================================================================
-// Public API Response Types
-// ============================================================================
-
 export type PublicProductsResponse = QueryData<ReturnType<typeof useGetProducts>>;
 export type PublicProduct = PublicProductsResponse extends Array<infer Item> ? Item : never;
 export type Product = PublicProduct;
-
 export type PublicDeliveryZonesResponse = QueryData<ReturnType<typeof useGetDeliveryZones>>;
 export type PublicDeliveryZoneState = PublicDeliveryZonesResponse extends Array<infer Item> ? Item : never;
 export type DeliveryZoneState = PublicDeliveryZoneState;
-export type DeliveryZone = PublicDeliveryZoneState extends { zones: Array<infer Zone> } ? Zone : never;
-
+export type DeliveryZone = PublicDeliveryZoneState extends {
+    zones: Array<infer Zone>;
+} ? Zone : never;
 export type PublicCartResponse = QueryData<ReturnType<typeof useGetCart>>;
 export type Cart = PublicCartResponse;
-export type CartItem = PublicCartResponse extends { items: Array<infer Item> } ? Item : never;
-
+export type CartItem = PublicCartResponse extends {
+    items: Array<infer Item>;
+} ? Item : never;
 export type PublicOrderResponse = QueryData<ReturnType<typeof useGetOrder>>;
 export type Order = PublicOrderResponse;
-export type OrderItem = Order extends { items: Array<infer Item> } ? Item : never;
+export type OrderItem = Order extends {
+    items: Array<infer Item>;
+} ? Item : never;
+export {};

package/dist/rpc-types.js

@@ -0,0 +1,7 @@
+/**
+ * Type extraction from React Query hooks
+ *
+ * The hooks already have proper Hono RPC type inference built-in.
+ * We extract the data types from UseQueryResult<T, E> to get the actual response types.
+ */
+export {};

package/{src/types.ts → dist/types.d.ts}

@@ -9,15 +9,9 @@
  * const [selectedBrand, setSelectedBrand] = useState<Brand | null>(null)
  * ```
  */
-
-// Re-export hooks so types and hooks can be imported together
 export * from './hooks/public';
 export * as admin from './hooks/admin';
-
-// Re-export all RPC-derived types
 export * from './rpc-types';
-
-// Additional derived types for convenience
 export type { PublicProduct as Product } from './rpc-types';
 export type { PublicDeliveryZoneState as DeliveryZoneState } from './rpc-types';
 export type { PublicCartResponse as CartResponse, PublicCartResponse as Cart } from './rpc-types';

package/dist/types.js

@@ -0,0 +1,16 @@
+/**
+ * Type exports for API client
+ *
+ * These types are derived directly from Hono RPC routes for end-to-end type safety.
+ *
+ * Usage in frontend:
+ * ```ts
+ * import type { Brand, InventoryItem } from '@oms/api-client'
+ * const [selectedBrand, setSelectedBrand] = useState<Brand | null>(null)
+ * ```
+ */
+// Re-export hooks so types and hooks can be imported together
+export * from './hooks/public';
+export * as admin from './hooks/admin';
+// Re-export all RPC-derived types
+export * from './rpc-types';

package/dist/utils/query-keys.d.ts

@@ -0,0 +1,106 @@
+/**
+ * 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 declare const queryKeys: {
+    public: {
+        all: readonly ["public"];
+        carts: {
+            all: readonly ["public", "carts"];
+            detail: (id: string) => readonly ["public", "carts", string];
+        };
+        orders: {
+            all: readonly ["public", "orders"];
+            detail: (id: string, token: string) => readonly ["public", "orders", string, string];
+        };
+        products: {
+            all: readonly ["public", "products"];
+            list: (brandId: string) => readonly ["public", "products", string];
+            detail: (productId: string) => readonly ["public", "products", string];
+        };
+        deliveryZones: {
+            all: readonly ["public", "delivery-zones"];
+            list: (brandId?: string) => readonly ["public", "delivery-zones", string];
+        };
+        brands: {
+            all: readonly ["public", "brands"];
+            detail: (slug: string) => readonly ["public", "brands", string];
+        };
+    };
+    admin: {
+        all: readonly ["admin"];
+        orders: {
+            all: readonly ["admin", "orders"];
+            list: () => readonly ["admin", "orders", "list"];
+            detail: (id: string) => readonly ["admin", "orders", string];
+        };
+        brands: {
+            all: readonly ["admin", "brands"];
+            list: () => readonly ["admin", "brands", "list"];
+            detail: (id: string) => readonly ["admin", "brands", string];
+        };
+        products: {
+            all: readonly ["admin", "products"];
+            list: (brandId?: string) => readonly ["admin", "products", "list", string];
+            detail: (id: string) => readonly ["admin", "products", string];
+        };
+        variants: {
+            all: readonly ["admin", "variants"];
+            list: () => readonly ["admin", "variants", "list"];
+            detail: (id: string) => readonly ["admin", "variants", string];
+            search: (params?: any) => readonly ["admin", "variants", "search", any];
+            byProduct: (productId: string) => readonly ["admin", "variants", "product", string];
+            inventory: (id: string) => readonly ["admin", "variants", string, "inventory"];
+        };
+        warehouses: {
+            all: readonly ["admin", "warehouses"];
+            list: () => readonly ["admin", "warehouses", "list"];
+            detail: (id: string) => readonly ["admin", "warehouses", string];
+            inventory: (id: string) => readonly ["admin", "warehouses", string, "inventory"];
+        };
+        inventory: {
+            all: readonly ["admin", "inventory"];
+            list: (params?: any) => readonly ["admin", "inventory", "list", any];
+            transactions: (params?: any) => readonly ["admin", "inventory", "transactions", any];
+            lowStock: (brandId?: string) => readonly ["admin", "inventory", "low-stock", string];
+        };
+        customers: {
+            all: readonly ["admin", "customers"];
+            history: (phone: string) => readonly ["admin", "customers", "history", string];
+        };
+        stats: {
+            all: readonly ["admin", "stats"];
+            overview: (brandId?: string) => readonly ["admin", "stats", "overview", string];
+        };
+        abandonedCarts: {
+            all: readonly ["admin", "abandoned-carts"];
+            list: (params?: any) => readonly ["admin", "abandoned-carts", "list", any];
+            detail: (id: string) => readonly ["admin", "abandoned-carts", string];
+            stats: (brandId?: string) => readonly ["admin", "abandoned-carts", "stats", string];
+        };
+        discountCodes: {
+            all: readonly ["admin", "discount-codes"];
+            list: (params?: any) => readonly ["admin", "discount-codes", "list", any];
+            detail: (id: string) => readonly ["admin", "discount-codes", string];
+            analytics: (id: string) => readonly ["admin", "discount-codes", string, "analytics"];
+            overviewStats: () => readonly ["admin", "discount-codes", "stats", "overview"];
+        };
+        deliveryZones: {
+            all: readonly ["admin", "delivery-zones"];
+            states: {
+                all: readonly ["admin", "delivery-zones", "states"];
+                list: () => readonly ["admin", "delivery-zones", "states", "list"];
+                detail: (id: string) => readonly ["admin", "delivery-zones", "states", string];
+            };
+            zones: {
+                all: readonly ["admin", "delivery-zones", "zones"];
+                list: (params?: any) => readonly ["admin", "delivery-zones", "zones", "list", any];
+                detail: (id: string) => readonly ["admin", "delivery-zones", "zones", string];
+            };
+        };
+    };
+};

package/dist/utils/query-keys.js

@@ -0,0 +1,108 @@
+/**
+ * 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'],
+        carts: {
+            all: ['public', 'carts'],
+            detail: (id) => ['public', 'carts', id],
+        },
+        orders: {
+            all: ['public', 'orders'],
+            detail: (id, token) => ['public', 'orders', id, token],
+        },
+        products: {
+            all: ['public', 'products'],
+            list: (brandId) => ['public', 'products', brandId],
+            detail: (productId) => ['public', 'products', productId],
+        },
+        deliveryZones: {
+            all: ['public', 'delivery-zones'],
+            list: (brandId) => ['public', 'delivery-zones', brandId],
+        },
+        brands: {
+            all: ['public', 'brands'],
+            detail: (slug) => ['public', 'brands', slug],
+        },
+    },
+    // Admin API keys (RPC is now the default)
+    admin: {
+        all: ['admin'],
+        orders: {
+            all: ['admin', 'orders'],
+            list: () => ['admin', 'orders', 'list'],
+            detail: (id) => ['admin', 'orders', id],
+        },
+        brands: {
+            all: ['admin', 'brands'],
+            list: () => ['admin', 'brands', 'list'],
+            detail: (id) => ['admin', 'brands', id],
+        },
+        products: {
+            all: ['admin', 'products'],
+            list: (brandId) => ['admin', 'products', 'list', brandId],
+            detail: (id) => ['admin', 'products', id],
+        },
+        variants: {
+            all: ['admin', 'variants'],
+            list: () => ['admin', 'variants', 'list'],
+            detail: (id) => ['admin', 'variants', id],
+            search: (params) => ['admin', 'variants', 'search', params],
+            byProduct: (productId) => ['admin', 'variants', 'product', productId],
+            inventory: (id) => ['admin', 'variants', id, 'inventory'],
+        },
+        warehouses: {
+            all: ['admin', 'warehouses'],
+            list: () => ['admin', 'warehouses', 'list'],
+            detail: (id) => ['admin', 'warehouses', id],
+            inventory: (id) => ['admin', 'warehouses', id, 'inventory'],
+        },
+        inventory: {
+            all: ['admin', 'inventory'],
+            list: (params) => ['admin', 'inventory', 'list', params],
+            transactions: (params) => ['admin', 'inventory', 'transactions', params],
+            lowStock: (brandId) => ['admin', 'inventory', 'low-stock', brandId],
+        },
+        customers: {
+            all: ['admin', 'customers'],
+            history: (phone) => ['admin', 'customers', 'history', phone],
+        },
+        stats: {
+            all: ['admin', 'stats'],
+            overview: (brandId) => ['admin', 'stats', 'overview', brandId],
+        },
+        abandonedCarts: {
+            all: ['admin', 'abandoned-carts'],
+            list: (params) => ['admin', 'abandoned-carts', 'list', params],
+            detail: (id) => ['admin', 'abandoned-carts', id],
+            stats: (brandId) => ['admin', 'abandoned-carts', 'stats', brandId],
+        },
+        discountCodes: {
+            all: ['admin', 'discount-codes'],
+            list: (params) => ['admin', 'discount-codes', 'list', params],
+            detail: (id) => ['admin', 'discount-codes', id],
+            analytics: (id) => ['admin', 'discount-codes', id, 'analytics'],
+            overviewStats: () => ['admin', 'discount-codes', 'stats', 'overview'],
+        },
+        deliveryZones: {
+            all: ['admin', 'delivery-zones'],
+            states: {
+                all: ['admin', 'delivery-zones', 'states'],
+                list: () => ['admin', 'delivery-zones', 'states', 'list'],
+                detail: (id) => ['admin', 'delivery-zones', 'states', id],
+            },
+            zones: {
+                all: ['admin', 'delivery-zones', 'zones'],
+                list: (params) => ['admin', 'delivery-zones', 'zones', 'list', params],
+                detail: (id) => ['admin', 'delivery-zones', 'zones', id],
+            },
+        },
+    },
+};

package/package.json

@@ -1,19 +1,34 @@
 {
   "name": "@instockng/api-client",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "React Query hooks for OMS API",
-  "main": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./fetchers": "./src/fetchers/index.ts",
-    "./public": "./src/hooks/public/index.ts",
-    "./admin": "./src/hooks/admin/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./fetchers": {
+      "types": "./dist/fetchers/index.d.ts",
+      "import": "./dist/fetchers/index.js"
+    },
+    "./admin": {
+      "types": "./dist/hooks/admin/index.d.ts",
+      "import": "./dist/hooks/admin/index.js"
+    }
   },
   "files": [
-    "src",
+    "dist",
     "README.md"
   ],
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "build": "tsc --project tsconfig.build.json --noEmitOnError false",
+    "generate-types": "node scripts/generate-backend-types.mjs",
+    "prebuild": "pnpm run generate-types",
+    "prepublishOnly": "pnpm run generate-types"
+  },
   "keywords": [
     "api",
     "react-query",
@@ -37,9 +52,5 @@
     "axios": "^1.6.5",
     "react": "^19.0.0",
     "typescript": "^5.3.3"
-  },
-  "scripts": {
-    "type-check": "tsc --noEmit",
-    "build": "tsc --build"
   }
-}
+}

package/src/client.ts

@@ -1,57 +0,0 @@
-/**
- * Axios client configuration for OMS API
- */
-
-import axios, { AxiosInstance, AxiosError } from 'axios';
-
-export interface ApiClientConfig {
-  baseURL: string;
-  onError?: (error: AxiosError) => void;
-}
-
-let apiClient: AxiosInstance | null = null;
-
-/**
- * Initialize the API client with configuration
- */
-export function initializeApiClient(config: ApiClientConfig): AxiosInstance {
-  apiClient = axios.create({
-    baseURL: config.baseURL,
-    headers: {
-      'Content-Type': 'application/json',
-    },
-  });
-
-  // Response interceptor for error handling
-  apiClient.interceptors.response.use(
-    (response) => response,
-    (error: AxiosError) => {
-      // Call custom error handler if provided
-      if (config.onError) {
-        config.onError(error);
-      }
-      return Promise.reject(error);
-    }
-  );
-
-  return apiClient;
-}
-
-/**
- * Get the current API client instance
- */
-export function getApiClient(): AxiosInstance {
-  if (!apiClient) {
-    throw new Error(
-      'API client not initialized. Make sure to wrap your app with ApiClientProvider.'
-    );
-  }
-  return apiClient;
-}
-
-/**
- * Reset the API client (mainly for testing)
- */
-export function resetApiClient(): void {
-  apiClient = null;
-}