@instockng/api-client 1.0.5 → 1.0.6

package/dist/packages/api-client/src/rpc-client.js

@@ -1,78 +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';
-/**
- * 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

@@ -1,76 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

@@ -1,37 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,106 +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 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

@@ -1,108 +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'],
-        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],
-            },
-        },
-    },
-};