@instockng/api-client 1.0.2 → 1.0.4

package/dist/packages/api-client/src/hooks/public/products.d.ts

@@ -0,0 +1,398 @@
+/**
+ * Type-safe RPC hooks for product operations
+ *
+ * These hooks use Hono RPC client with types directly from the backend,
+ * providing end-to-end type safety without code generation.
+ */
+import { UseQueryOptions } from '@tanstack/react-query';
+import { fetchProductsByBrand, fetchProductBySlug } from '../../fetchers/products';
+/**
+ * Hook to get products by brand using RPC
+ *
+ * @param brandId - Brand UUID
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: products, isLoading } = useGetProducts('brand-123');
+ * console.log(products?.data[0].name); // Fully typed!
+ * ```
+ */
+export declare function useGetProducts(brandId: string, options?: Omit<UseQueryOptions<Awaited<ReturnType<typeof fetchProductsByBrand>>, Error>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        name: string;
+        id: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    variants: {
+        createdAt: string;
+        updatedAt: string;
+        price: number;
+        deletedAt: string;
+        name: string | null;
+        id: string;
+        isActive: boolean;
+        thumbnailUrl: string | null;
+        productId: string;
+        sku: string;
+        trackInventory: boolean;
+        lowStockThreshold: number | null;
+    }[];
+    name: string;
+    id: string;
+    slug: string;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+    brandId: string;
+    isActive: boolean;
+    description: string | null;
+    thumbnailUrl: string | null;
+    quantityDiscounts: string | number | boolean | {
+        [x: string]: string | number | boolean | /*elided*/ any | {
+            [x: number]: string | number | boolean | /*elided*/ any | /*elided*/ any;
+            length: number;
+            toString: never;
+            toLocaleString: never;
+            pop: never;
+            push: never;
+            concat: never;
+            join: never;
+            reverse: never;
+            shift: never;
+            slice: never;
+            sort: never;
+            splice: never;
+            unshift: never;
+            indexOf: never;
+            lastIndexOf: never;
+            every: never;
+            some: never;
+            forEach: never;
+            map: never;
+            filter: never;
+            reduce: never;
+            reduceRight: never;
+            find: never;
+            findIndex: never;
+            fill: never;
+            copyWithin: never;
+            entries: never;
+            keys: never;
+            values: never;
+            includes: never;
+            flatMap: never;
+            flat: never;
+            [Symbol.iterator]: never;
+            readonly [Symbol.unscopables]: {
+                [x: number]: boolean;
+                length?: boolean;
+                toString?: boolean;
+                toLocaleString?: boolean;
+                pop?: boolean;
+                push?: boolean;
+                concat?: boolean;
+                join?: boolean;
+                reverse?: boolean;
+                shift?: boolean;
+                slice?: boolean;
+                sort?: boolean;
+                splice?: boolean;
+                unshift?: boolean;
+                indexOf?: boolean;
+                lastIndexOf?: boolean;
+                every?: boolean;
+                some?: boolean;
+                forEach?: boolean;
+                map?: boolean;
+                filter?: boolean;
+                reduce?: boolean;
+                reduceRight?: boolean;
+                find?: boolean;
+                findIndex?: boolean;
+                fill?: boolean;
+                copyWithin?: boolean;
+                entries?: boolean;
+                keys?: boolean;
+                values?: boolean;
+                includes?: boolean;
+                flatMap?: boolean;
+                flat?: boolean;
+            };
+        };
+    } | {
+        [x: number]: string | number | boolean | {
+            [x: string]: string | number | boolean | /*elided*/ any | /*elided*/ any;
+        } | /*elided*/ any;
+        length: number;
+        toString: never;
+        toLocaleString: never;
+        pop: never;
+        push: never;
+        concat: never;
+        join: never;
+        reverse: never;
+        shift: never;
+        slice: never;
+        sort: never;
+        splice: never;
+        unshift: never;
+        indexOf: never;
+        lastIndexOf: never;
+        every: never;
+        some: never;
+        forEach: never;
+        map: never;
+        filter: never;
+        reduce: never;
+        reduceRight: never;
+        find: never;
+        findIndex: never;
+        fill: never;
+        copyWithin: never;
+        entries: never;
+        keys: never;
+        values: never;
+        includes: never;
+        flatMap: never;
+        flat: never;
+        [Symbol.iterator]: never;
+        readonly [Symbol.unscopables]: {
+            [x: number]: boolean;
+            length?: boolean;
+            toString?: boolean;
+            toLocaleString?: boolean;
+            pop?: boolean;
+            push?: boolean;
+            concat?: boolean;
+            join?: boolean;
+            reverse?: boolean;
+            shift?: boolean;
+            slice?: boolean;
+            sort?: boolean;
+            splice?: boolean;
+            unshift?: boolean;
+            indexOf?: boolean;
+            lastIndexOf?: boolean;
+            every?: boolean;
+            some?: boolean;
+            forEach?: boolean;
+            map?: boolean;
+            filter?: boolean;
+            reduce?: boolean;
+            reduceRight?: boolean;
+            find?: boolean;
+            findIndex?: boolean;
+            fill?: boolean;
+            copyWithin?: boolean;
+            entries?: boolean;
+            keys?: boolean;
+            values?: boolean;
+            includes?: boolean;
+            flatMap?: boolean;
+            flat?: boolean;
+        };
+    };
+}[], Error>;
+/**
+ * Hook to get a single product by slug using RPC
+ *
+ * @param slug - Product slug
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: product, isLoading } = useGetProduct('cotton-t-shirt');
+ * console.log(product?.name); // Fully typed!
+ * ```
+ */
+export declare function useGetProduct(slug: string, options?: Omit<UseQueryOptions<Awaited<ReturnType<typeof fetchProductBySlug>>, Error>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        name: string;
+        id: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    variants: {
+        createdAt: string;
+        updatedAt: string;
+        price: number;
+        deletedAt: string;
+        name: string | null;
+        id: string;
+        isActive: boolean;
+        thumbnailUrl: string | null;
+        productId: string;
+        sku: string;
+        trackInventory: boolean;
+        lowStockThreshold: number | null;
+    }[];
+    name: string;
+    id: string;
+    slug: string;
+    createdAt: string;
+    updatedAt: string;
+    deletedAt: string;
+    brandId: string;
+    isActive: boolean;
+    description: string | null;
+    thumbnailUrl: string | null;
+    quantityDiscounts: string | number | boolean | {
+        [x: string]: string | number | boolean | /*elided*/ any | {
+            [x: number]: string | number | boolean | /*elided*/ any | /*elided*/ any;
+            length: number;
+            toString: never;
+            toLocaleString: never;
+            pop: never;
+            push: never;
+            concat: never;
+            join: never;
+            reverse: never;
+            shift: never;
+            slice: never;
+            sort: never;
+            splice: never;
+            unshift: never;
+            indexOf: never;
+            lastIndexOf: never;
+            every: never;
+            some: never;
+            forEach: never;
+            map: never;
+            filter: never;
+            reduce: never;
+            reduceRight: never;
+            find: never;
+            findIndex: never;
+            fill: never;
+            copyWithin: never;
+            entries: never;
+            keys: never;
+            values: never;
+            includes: never;
+            flatMap: never;
+            flat: never;
+            [Symbol.iterator]: never;
+            readonly [Symbol.unscopables]: {
+                [x: number]: boolean;
+                length?: boolean;
+                toString?: boolean;
+                toLocaleString?: boolean;
+                pop?: boolean;
+                push?: boolean;
+                concat?: boolean;
+                join?: boolean;
+                reverse?: boolean;
+                shift?: boolean;
+                slice?: boolean;
+                sort?: boolean;
+                splice?: boolean;
+                unshift?: boolean;
+                indexOf?: boolean;
+                lastIndexOf?: boolean;
+                every?: boolean;
+                some?: boolean;
+                forEach?: boolean;
+                map?: boolean;
+                filter?: boolean;
+                reduce?: boolean;
+                reduceRight?: boolean;
+                find?: boolean;
+                findIndex?: boolean;
+                fill?: boolean;
+                copyWithin?: boolean;
+                entries?: boolean;
+                keys?: boolean;
+                values?: boolean;
+                includes?: boolean;
+                flatMap?: boolean;
+                flat?: boolean;
+            };
+        };
+    } | {
+        [x: number]: string | number | boolean | {
+            [x: string]: string | number | boolean | /*elided*/ any | /*elided*/ any;
+        } | /*elided*/ any;
+        length: number;
+        toString: never;
+        toLocaleString: never;
+        pop: never;
+        push: never;
+        concat: never;
+        join: never;
+        reverse: never;
+        shift: never;
+        slice: never;
+        sort: never;
+        splice: never;
+        unshift: never;
+        indexOf: never;
+        lastIndexOf: never;
+        every: never;
+        some: never;
+        forEach: never;
+        map: never;
+        filter: never;
+        reduce: never;
+        reduceRight: never;
+        find: never;
+        findIndex: never;
+        fill: never;
+        copyWithin: never;
+        entries: never;
+        keys: never;
+        values: never;
+        includes: never;
+        flatMap: never;
+        flat: never;
+        [Symbol.iterator]: never;
+        readonly [Symbol.unscopables]: {
+            [x: number]: boolean;
+            length?: boolean;
+            toString?: boolean;
+            toLocaleString?: boolean;
+            pop?: boolean;
+            push?: boolean;
+            concat?: boolean;
+            join?: boolean;
+            reverse?: boolean;
+            shift?: boolean;
+            slice?: boolean;
+            sort?: boolean;
+            splice?: boolean;
+            unshift?: boolean;
+            indexOf?: boolean;
+            lastIndexOf?: boolean;
+            every?: boolean;
+            some?: boolean;
+            forEach?: boolean;
+            map?: boolean;
+            filter?: boolean;
+            reduce?: boolean;
+            reduceRight?: boolean;
+            find?: boolean;
+            findIndex?: boolean;
+            fill?: boolean;
+            copyWithin?: boolean;
+            entries?: boolean;
+            keys?: boolean;
+            values?: boolean;
+            includes?: boolean;
+            flatMap?: boolean;
+            flat?: boolean;
+        };
+    };
+}, Error>;

package/dist/packages/api-client/src/hooks/public/products.js

@@ -0,0 +1,47 @@
+/**
+ * Type-safe RPC hooks for product operations
+ *
+ * These hooks use Hono RPC client with types directly from the backend,
+ * providing end-to-end type safety without code generation.
+ */
+import { useQueryUnwrapped } from '../use-query-unwrapped';
+import { queryKeys } from '../../utils/query-keys';
+import { fetchProductsByBrand, fetchProductBySlug } from '../../fetchers/products';
+/**
+ * Hook to get products by brand using RPC
+ *
+ * @param brandId - Brand UUID
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: products, isLoading } = useGetProducts('brand-123');
+ * console.log(products?.data[0].name); // Fully typed!
+ * ```
+ */
+export function useGetProducts(brandId, options) {
+    return useQueryUnwrapped({
+        queryKey: queryKeys.public.products.list(brandId),
+        queryFn: () => fetchProductsByBrand(brandId),
+        ...options,
+    });
+}
+/**
+ * Hook to get a single product by slug using RPC
+ *
+ * @param slug - Product slug
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: product, isLoading } = useGetProduct('cotton-t-shirt');
+ * console.log(product?.name); // Fully typed!
+ * ```
+ */
+export function useGetProduct(slug, options) {
+    return useQueryUnwrapped({
+        queryKey: queryKeys.public.products.detail(slug),
+        queryFn: () => fetchProductBySlug(slug),
+        ...options,
+    });
+}

package/dist/packages/api-client/src/hooks/use-query-unwrapped.d.ts

@@ -0,0 +1,20 @@
+import { 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 declare function useQueryUnwrapped<TData, TError = Error, TQueryKey extends readonly unknown[] = readonly unknown[]>(options: UseQueryOptions<TData, TError, TData, TQueryKey>): UseQueryResult<Exclude<TData, {
+    error: any;
+}>, TError>;

package/dist/packages/api-client/src/hooks/use-query-unwrapped.js

@@ -0,0 +1,22 @@
+import { useQuery } 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(options) {
+    const result = useQuery(options);
+    // Cast the data to exclude error types since we throw on errors
+    return result;
+}

package/dist/packages/api-client/src/hooks/useApiConfig.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Hook to access API configuration from context
+ */
+export interface ApiConfig {
+    baseURL: string;
+    authToken: string;
+}
+/**
+ * Get API configuration from context
+ */
+export declare function useApiConfig(): ApiConfig;

package/dist/packages/api-client/src/hooks/useApiConfig.js

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

package/dist/packages/api-client/src/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @oms/api-client
+ *
+ * Type-safe React Query hooks for OMS API using Hono RPC
+ */
+export { ApiClientProvider, useApiClientContext } from './provider';
+export type { ApiClientProviderProps } from './provider';
+export { useApiConfig } from './hooks/useApiConfig';
+export type { ApiConfig } from './hooks/useApiConfig';
+export { getApiClient, initializeApiClient, resetApiClient } from './client';
+export type { ApiClientConfig } from './client';
+export { createRpcClients, createAdminRpcClients, authHeaders } from './rpc-client';
+export type { RpcClients, AdminRpcClients } from './rpc-client';
+export * from './fetchers';
+export { queryKeys } from './utils/query-keys';
+export * from './hooks/public';
+import * as publicHooks from './hooks/public';
+import * as adminHooks from './hooks/admin';
+export { publicHooks as publicApi, adminHooks as adminApi };
+export type * from './types';

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

@@ -0,0 +1,25 @@
+/**
+ * @oms/api-client
+ *
+ * Type-safe React Query hooks for OMS API using Hono RPC
+ */
+// Export provider
+export { ApiClientProvider, useApiClientContext } from './provider';
+// Export API config hook
+export { useApiConfig } from './hooks/useApiConfig';
+// Export client utilities (legacy axios client - deprecated)
+export { getApiClient, initializeApiClient, resetApiClient } from './client';
+// Export RPC client utilities (type-safe Hono RPC)
+export { createRpcClients, createAdminRpcClients, authHeaders } from './rpc-client';
+// Export fetchers for Server Components (can be used without hooks)
+export * from './fetchers';
+// Export query keys for advanced usage
+export { queryKeys } from './utils/query-keys';
+// Export all public hooks directly from main package
+// These can be imported as: import { useGetCart } from '@oms/api-client'
+export * from './hooks/public';
+// Export namespaced versions for backward compatibility
+// These can be imported as: import { publicApi, adminApi } from '@oms/api-client'
+import * as publicHooks from './hooks/public';
+import * as adminHooks from './hooks/admin';
+export { publicHooks as publicApi, adminHooks as adminApi };

package/dist/packages/api-client/src/provider.d.ts

@@ -0,0 +1,33 @@
+/**
+ * React context provider for API client configuration
+ */
+import { ReactNode } from 'react';
+import { QueryClient } from '@tanstack/react-query';
+import { AxiosError } from 'axios';
+interface ApiClientContextValue {
+    baseURL: string;
+    authToken?: string;
+}
+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 declare function ApiClientProvider({ children, baseURL, authToken, onError, queryClient: externalQueryClient }: ApiClientProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to access API client context
+ */
+export declare function useApiClientContext(): ApiClientContextValue;
+export {};

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

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * React context provider for API client configuration
+ */
+import { createContext, useContext, useEffect, useMemo } from 'react';
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { initializeApiClient } from './client';
+const ApiClientContext = createContext(null);
+/**
+ * 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 }) {
+    // Initialize client synchronously on first render
+    const config = {
+        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 (_jsx(QueryClientProvider, { client: queryClient, children: _jsx(ApiClientContext.Provider, { value: { baseURL, authToken }, children: children }) }));
+}
+/**
+ * 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;
+}