@instockng/api-client 1.0.6 → 1.0.8

package/dist/packages/api-client/src/hooks/admin/orders.js

@@ -0,0 +1,178 @@
+/**
+ * Type-safe admin RPC hooks for order management
+ *
+ * These hooks use Hono RPC client with types directly from the backend,
+ * providing end-to-end type safety without code generation.
+ */
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useQueryUnwrapped } from '../use-query-unwrapped';
+import { createAdminRpcClients, authHeaders } from '../../rpc-client';
+import { queryKeys } from '../../utils/query-keys';
+import { useApiConfig } from '../useApiConfig';
+/**
+ * Hook to list all orders with pagination using admin RPC
+ *
+ * @param filters - Query parameters for filtering orders
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: orders, isLoading } = useListOrders({ search: 'john', page: 1 });
+ * ```
+ */
+export function useListOrders(filters, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    return useQueryUnwrapped({
+        queryKey: queryKeys.admin.orders.list(filters),
+        queryFn: async () => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            // Clean undefined values from filters
+            const cleanFilters = filters ? Object.fromEntries(Object.entries(filters).filter(([_, v]) => v !== undefined)) : undefined;
+            const res = await clients.orders.index.$get({ query: cleanFilters }, authHeaders(token));
+            if (!res.ok) {
+                throw new Error(`Failed to fetch orders: ${res.statusText}`);
+            }
+            return res.json();
+        },
+        ...options,
+    });
+}
+/**
+ * Hook to get order by ID using admin RPC
+ *
+ * @param orderId - Order UUID
+ * @param options - React Query options
+ *
+ * @example
+ * ```tsx
+ * const { data: order } = useGetOrder('order-123');
+ * ```
+ */
+export function useGetOrder(orderId, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    return useQueryUnwrapped({
+        queryKey: queryKeys.admin.orders.detail(orderId),
+        queryFn: async () => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.orders[':id'].$get({ param: { id: orderId } }, authHeaders(token));
+            if (!res.ok) {
+                throw new Error(`Failed to fetch order: ${res.statusText}`);
+            }
+            return res.json();
+        },
+        ...options,
+    });
+}
+/**
+ * Hook to create a new order using admin RPC
+ *
+ * @param options - React Query mutation options
+ *
+ * @example
+ * ```tsx
+ * const createOrder = useCreateOrder();
+ * createOrder.mutate({
+ *   brandSlug: 'my-brand',
+ *   items: [{ sku: 'SKU-001', quantity: 2 }],
+ *   // ... other order fields
+ * });
+ * ```
+ */
+export function useCreateOrder(options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (data) => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.orders.index.$post({ json: data }, authHeaders(token));
+            if (!res.ok) {
+                throw new Error(`Failed to create order: ${res.statusText}`);
+            }
+            return res.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.admin.orders.all });
+        },
+        ...options,
+    });
+}
+/**
+ * Hook to update an order using admin RPC
+ *
+ * @param orderId - Order UUID
+ * @param options - React Query mutation options
+ */
+export function useUpdateOrder(orderId, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (data) => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.orders[':id'].$patch({ param: { id: orderId }, json: data }, authHeaders(token));
+            if (!res.ok) {
+                throw new Error(`Failed to update order: ${res.statusText}`);
+            }
+            return res.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.admin.orders.detail(orderId) });
+            queryClient.invalidateQueries({ queryKey: queryKeys.admin.orders.all });
+        },
+        ...options,
+    });
+}
+/**
+ * Hook to update order status using admin RPC
+ *
+ * @param orderId - Order UUID
+ * @param options - React Query mutation options
+ */
+export function useUpdateOrderStatus(orderId, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (data) => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.orders[':id'].status.$patch({ param: { id: orderId }, json: data }, authHeaders(token));
+            if (!res.ok) {
+                throw new Error(`Failed to update order status: ${res.statusText}`);
+            }
+            return res.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.admin.orders.detail(orderId) });
+            queryClient.invalidateQueries({ queryKey: queryKeys.admin.orders.all });
+        },
+        ...options,
+    });
+}
+/**
+ * Hook to delete an order using admin RPC
+ *
+ * @param orderId - Order UUID
+ * @param options - React Query mutation options
+ */
+export function useDeleteOrder(orderId, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async () => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.orders[':id'].$delete({ param: { id: orderId } }, authHeaders(token));
+            if (!res.ok) {
+                throw new Error(`Failed to delete order: ${res.statusText}`);
+            }
+            return res.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.admin.orders.all });
+        },
+        ...options,
+    });
+}

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

@@ -0,0 +1,374 @@
+/**
+ * Type-safe admin RPC hooks for product management
+ */
+import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import { createAdminRpcClients } from '../../rpc-client';
+export declare function useListProducts(brandId?: string, options?: Omit<UseQueryOptions<Awaited<ReturnType<Awaited<ReturnType<ReturnType<typeof createAdminRpcClients>['products']['index']['$get']>>['json']>>, Error>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    variants: {
+        createdAt: string;
+        updatedAt: string;
+        price: number;
+        deletedAt: string;
+        id: string;
+        name: string | null;
+        isActive: boolean;
+        thumbnailUrl: string | null;
+        productId: string;
+        sku: string;
+        trackInventory: boolean;
+        lowStockThreshold: number | null;
+    }[];
+    id: string;
+    name: 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>;
+export declare function useGetProduct(productId: string, options?: Omit<UseQueryOptions<Awaited<ReturnType<Awaited<ReturnType<ReturnType<typeof createAdminRpcClients>['products'][':id']['$get']>>['json']>>, Error>, 'queryKey' | 'queryFn'>): import("@tanstack/react-query").UseQueryResult<{
+    brand: {
+        createdAt: string;
+        updatedAt: string;
+        deletedAt: string;
+        id: string;
+        name: string;
+        slug: string;
+        logoUrl: string | null;
+        siteUrl: string;
+        domain: string;
+        metaPixelId: string | null;
+    };
+    variants: {
+        createdAt: string;
+        updatedAt: string;
+        price: number;
+        deletedAt: string;
+        id: string;
+        name: string | null;
+        isActive: boolean;
+        thumbnailUrl: string | null;
+        productId: string;
+        sku: string;
+        trackInventory: boolean;
+        lowStockThreshold: number | null;
+    }[];
+    id: string;
+    name: 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>;
+export declare function useCreateProduct(options?: UseMutationOptions<any, Error, any>): import("@tanstack/react-query").UseMutationResult<any, Error, any, unknown>;
+export declare function useUpdateProduct(productId: string, options?: UseMutationOptions<any, Error, any>): import("@tanstack/react-query").UseMutationResult<any, Error, any, unknown>;
+export declare function useDeleteProduct(productId: string, options?: UseMutationOptions<any, Error, void>): import("@tanstack/react-query").UseMutationResult<any, Error, void, unknown>;

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

@@ -0,0 +1,89 @@
+/**
+ * Type-safe admin RPC hooks for product management
+ */
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useQueryUnwrapped } from '../use-query-unwrapped';
+import { createAdminRpcClients, authHeaders } from '../../rpc-client';
+import { queryKeys } from '../../utils/query-keys';
+import { useApiConfig } from '../useApiConfig';
+export function useListProducts(brandId, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    return useQueryUnwrapped({
+        queryKey: queryKeys.admin.products.list(brandId),
+        queryFn: async () => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.products.index.$get(brandId ? { query: { brandId } } : {}, authHeaders(token));
+            if (!res.ok)
+                throw new Error(`Failed to fetch products: ${res.statusText}`);
+            return res.json();
+        },
+        ...options,
+    });
+}
+export function useGetProduct(productId, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    return useQueryUnwrapped({
+        queryKey: queryKeys.admin.products.detail(productId),
+        queryFn: async () => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.products[':id'].$get({ param: { id: productId } }, authHeaders(token));
+            if (!res.ok)
+                throw new Error(`Failed to fetch product: ${res.statusText}`);
+            return res.json();
+        },
+        ...options,
+    });
+}
+export function useCreateProduct(options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (data) => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.products.index.$post({ json: data }, authHeaders(token));
+            if (!res.ok)
+                throw new Error(`Failed to create product: ${res.statusText}`);
+            return res.json();
+        },
+        onSuccess: () => queryClient.invalidateQueries({ queryKey: queryKeys.admin.products.all }),
+        ...options,
+    });
+}
+export function useUpdateProduct(productId, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (data) => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.products[':id'].$patch({ param: { id: productId }, json: data }, authHeaders(token));
+            if (!res.ok)
+                throw new Error(`Failed to update product: ${res.statusText}`);
+            return res.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: queryKeys.admin.products.detail(productId) });
+            queryClient.invalidateQueries({ queryKey: queryKeys.admin.products.all });
+        },
+        ...options,
+    });
+}
+export function useDeleteProduct(productId, options) {
+    const { baseURL, getAuthToken } = useApiConfig();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async () => {
+            const token = await getAuthToken();
+            const clients = createAdminRpcClients(baseURL);
+            const res = await clients.products[':id'].$delete({ param: { id: productId } }, authHeaders(token));
+            if (!res.ok)
+                throw new Error(`Failed to delete product: ${res.statusText}`);
+            return res.json();
+        },
+        onSuccess: () => queryClient.invalidateQueries({ queryKey: queryKeys.admin.products.all }),
+        ...options,
+    });
+}