@instockng/api-client 1.0.3 → 1.0.5

package/dist/packages/api-client/src/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/dist/packages/api-client/src/rpc-types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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.
+ */
+import type { UseQueryResult } from '@tanstack/react-query';
+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 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 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 AdminAbandonedCartsResponse = QueryData<ReturnType<typeof useListAbandonedCarts>>;
+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 DiscountCodeFull = QueryData<ReturnType<typeof useGetDiscountCode>>;
+export type DiscountCodeAnalytics = QueryData<ReturnType<typeof useGetDiscountCodeAnalytics>>;
+export type AdminDeliveryZonesResponse = QueryData<ReturnType<typeof useListAdminDeliveryZones>>;
+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;
+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 PublicCartResponse = QueryData<ReturnType<typeof useGetCart>>;
+export type Cart = PublicCartResponse;
+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 {};

package/dist/packages/api-client/src/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/dist/packages/api-client/src/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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)
+ * ```
+ */
+import type { AdminOrderFull, PublicCartResponse } from './rpc-types';
+export * from './hooks/public';
+export * as admin from './hooks/admin';
+export * from './rpc-types';
+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';
+export type { PublicOrderResponse as Order } from './rpc-types';
+export type { AdminOrderFull } from './rpc-types';
+export type { AdminProductFull } from './rpc-types';
+export type { DiscountCodeFull } from './rpc-types';
+export type { AdminCustomerHistoryResponse as CustomerHistory } from './rpc-types';
+export type { AdminStatsResponse as AdminStats } from './rpc-types';
+export type { DiscountCodeAnalytics } from './rpc-types';
+export type { CartItem } from './rpc-types';
+export type { OrderItem } from './rpc-types';
+export type { DeliveryZone } from './rpc-types';
+export type { AdminStatsOverview } from './rpc-types';
+export type { RecentOrder } from './rpc-types';
+export type { Customer } from './rpc-types';
+export type { CustomerOrder } from './rpc-types';
+export type { AdminDeliveryZone } from './rpc-types';
+export type { AdminState } from './rpc-types';
+export type OrderStatus = AdminOrderFull['status'];
+export type ProspectReason = NonNullable<AdminOrderFull['prospectReason']>;
+export type PaymentMethod = PublicCartResponse['availablePaymentMethods'][number];

package/dist/packages/api-client/src/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/packages/api-client/src/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/packages/api-client/src/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],
+            },
+        },
+    },
+};