schemock 0.0.1

package/dist/react/index.d.ts

@@ -0,0 +1,316 @@
+import * as react from 'react';
+import react__default, { ReactNode } from 'react';
+import { QueryClient, UseQueryResult, UseMutationResult } from '@tanstack/react-query';
+import { A as Adapter } from '../types-c2AN3vky.js';
+import { M as Middleware } from '../types-C1MiZh1d.js';
+import { o as EntitySchema, s as ViewSchema } from '../types-C2bd2vgy.js';
+
+/**
+ * Value provided by the DataLayer context.
+ */
+interface DataLayerContextValue {
+    /** The adapter to use for data operations */
+    adapter: Adapter;
+    /** React Query client instance */
+    queryClient: QueryClient;
+    /** Registered entity schemas */
+    schemas: Map<string, EntitySchema>;
+    /** Middleware chain */
+    middleware: Middleware[];
+    /** Get schema by entity name */
+    getSchema: (name: string) => EntitySchema | undefined;
+}
+/**
+ * React context for the data layer.
+ *
+ * Holds the adapter, query client, and schema registry.
+ */
+declare const DataLayerContext: react.Context<DataLayerContextValue | null>;
+/**
+ * Hook to access the DataLayer context.
+ *
+ * @returns The DataLayer context value
+ * @throws Error if used outside of DataLayerProvider
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const { adapter, queryClient } = useDataLayerContext();
+ *
+ *   const handleRefresh = () => {
+ *     queryClient.invalidateQueries();
+ *   };
+ *
+ *   return <button onClick={handleRefresh}>Refresh</button>;
+ * }
+ * ```
+ */
+declare function useDataLayerContext(): DataLayerContextValue;
+/**
+ * Hook to get the current adapter.
+ *
+ * @returns The adapter instance
+ *
+ * @example
+ * ```typescript
+ * function MyComponent() {
+ *   const adapter = useAdapter();
+ *   // Use adapter directly for custom operations
+ * }
+ * ```
+ */
+declare function useAdapter(): Adapter;
+/**
+ * Hook to get the query client.
+ *
+ * @returns The QueryClient instance
+ */
+declare function useQueryClientFromContext(): QueryClient;
+
+/**
+ * DataLayerProvider - React context provider for data layer
+ *
+ * Wraps your application to provide adapter and query client
+ * to all data hooks.
+ *
+ * @module react/provider
+ * @category React
+ */
+
+/**
+ * Props for the DataLayerProvider component.
+ */
+interface DataLayerProviderProps {
+    /** The adapter to use for data operations */
+    adapter: Adapter;
+    /** Entity schemas to register */
+    schemas?: EntitySchema[];
+    /** Middleware chain to apply */
+    middleware?: Middleware[];
+    /** Custom QueryClient (optional, will create one if not provided) */
+    queryClient?: QueryClient;
+    /** Default query options */
+    defaultOptions?: {
+        /** Default stale time in ms */
+        staleTime?: number;
+        /** Default cache time in ms */
+        cacheTime?: number;
+        /** Default retry count */
+        retry?: number;
+    };
+    /** Child components */
+    children: ReactNode;
+}
+/**
+ * DataLayerProvider component.
+ *
+ * Provides the data layer context to all child components,
+ * enabling the use of useData, useMutate, and useView hooks.
+ *
+ * @example
+ * ```typescript
+ * import { DataLayerProvider } from 'schemock/react';
+ * import { createMockAdapter } from 'schemock/adapters';
+ *
+ * const adapter = createMockAdapter([userSchema, postSchema]);
+ *
+ * function App() {
+ *   return (
+ *     <DataLayerProvider adapter={adapter} schemas={[userSchema, postSchema]}>
+ *       <MyApp />
+ *     </DataLayerProvider>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom query client and middleware
+ * const queryClient = new QueryClient({
+ *   defaultOptions: { queries: { staleTime: 5000 } },
+ * });
+ *
+ * function App() {
+ *   return (
+ *     <DataLayerProvider
+ *       adapter={adapter}
+ *       schemas={schemas}
+ *       queryClient={queryClient}
+ *       middleware={[authMiddleware, loggerMiddleware]}
+ *     >
+ *       <MyApp />
+ *     </DataLayerProvider>
+ *   );
+ * }
+ * ```
+ */
+declare const DataLayerProvider: react__default.FC<DataLayerProviderProps>;
+
+/**
+ * React Hooks - Data fetching and mutation hooks
+ *
+ * Provides useData, useMutate, and useView hooks for
+ * React Query integration with Schemock.
+ *
+ * @module react/hooks
+ * @category React
+ */
+
+/**
+ * Options for useData hook.
+ */
+interface UseDataOptions<T> {
+    /** Fetch single entity by ID */
+    id?: string;
+    /** Relations to include */
+    include?: string[];
+    /** Filter conditions */
+    where?: Record<string, unknown>;
+    /** Number of items to fetch */
+    limit?: number;
+    /** Pagination offset */
+    offset?: number;
+    /** Ordering */
+    orderBy?: Record<string, 'asc' | 'desc'>;
+    /** Fields to select */
+    select?: string[];
+    /** Whether the query is enabled */
+    enabled?: boolean;
+    /** Stale time in ms */
+    staleTime?: number;
+    /** Placeholder data */
+    placeholderData?: T | T[];
+}
+/**
+ * useData hook for fetching entities.
+ *
+ * Fetches single or multiple entities based on options.
+ *
+ * @param entity - The entity schema to fetch
+ * @param options - Query options
+ * @returns React Query result
+ *
+ * @example
+ * ```typescript
+ * // Fetch single entity
+ * const { data: user } = useData(userSchema, { id: '123' });
+ *
+ * // Fetch multiple entities
+ * const { data: users } = useData(userSchema, {
+ *   where: { role: 'admin' },
+ *   limit: 10,
+ *   orderBy: { createdAt: 'desc' },
+ * });
+ *
+ * // Fetch with relations
+ * const { data: user } = useData(userSchema, {
+ *   id: '123',
+ *   include: ['posts', 'comments'],
+ * });
+ * ```
+ */
+declare function useData<T>(entity: EntitySchema<T>, options?: UseDataOptions<T>): UseQueryResult<T | T[]>;
+/**
+ * Result from useMutate hook.
+ */
+interface UseMutateResult<T> {
+    /** Create mutation */
+    create: UseMutationResult<T, Error, Partial<T>>;
+    /** Update mutation */
+    update: UseMutationResult<T, Error, {
+        id: string;
+        data: Partial<T>;
+    }>;
+    /** Delete mutation */
+    remove: UseMutationResult<void, Error, string>;
+}
+/**
+ * Options for useMutate hook.
+ */
+interface UseMutateOptions {
+    /** Invalidate queries on success */
+    invalidateOnSuccess?: boolean;
+    /** Specific query keys to invalidate */
+    invalidateQueries?: unknown[][];
+    /** Optimistic update function */
+    onOptimisticUpdate?: () => void;
+}
+/**
+ * useMutate hook for CRUD mutations.
+ *
+ * Provides create, update, and delete mutations for an entity.
+ *
+ * @param entity - The entity schema
+ * @param options - Mutation options
+ * @returns Object with create, update, and remove mutations
+ *
+ * @example
+ * ```typescript
+ * const { create, update, remove } = useMutate(userSchema);
+ *
+ * // Create
+ * const handleCreate = async () => {
+ *   await create.mutateAsync({ name: 'John', email: 'john@example.com' });
+ * };
+ *
+ * // Update
+ * const handleUpdate = async (id: string) => {
+ *   await update.mutateAsync({ id, data: { name: 'Jane' } });
+ * };
+ *
+ * // Delete
+ * const handleDelete = async (id: string) => {
+ *   await remove.mutateAsync(id);
+ * };
+ * ```
+ */
+declare function useMutate<T>(entity: EntitySchema<T>, options?: UseMutateOptions): UseMutateResult<T>;
+/**
+ * Options for useView hook.
+ */
+interface UseViewOptions<T> {
+    /** URL parameters for the view */
+    params?: Record<string, string>;
+    /** Whether the query is enabled */
+    enabled?: boolean;
+    /** Stale time in ms */
+    staleTime?: number;
+    /** Placeholder data */
+    placeholderData?: T;
+}
+/**
+ * useView hook for fetching computed views.
+ *
+ * Fetches data from a view schema endpoint.
+ *
+ * @param view - The view schema
+ * @param options - View options
+ * @returns React Query result
+ *
+ * @example
+ * ```typescript
+ * const userFullView = defineView('user-full', ...);
+ *
+ * const { data } = useView(userFullView, { params: { id: '123' } });
+ * ```
+ */
+declare function useView<T>(view: ViewSchema, options?: UseViewOptions<T>): UseQueryResult<T>;
+/**
+ * Hook to prefetch data.
+ *
+ * @param entity - The entity schema
+ * @param options - Data options
+ *
+ * @example
+ * ```typescript
+ * const prefetchUser = usePrefetch(userSchema);
+ *
+ * // Prefetch on hover
+ * <div onMouseEnter={() => prefetchUser({ id: '123' })}>
+ *   User Profile
+ * </div>
+ * ```
+ */
+declare function usePrefetch<T>(entity: EntitySchema<T>): (options?: UseDataOptions<T>) => Promise<void>;
+
+export { DataLayerContext, type DataLayerContextValue, DataLayerProvider, type DataLayerProviderProps, type UseDataOptions, type UseMutateOptions, type UseMutateResult, type UseViewOptions, useAdapter, useData, useDataLayerContext, useMutate, usePrefetch, useQueryClientFromContext, useView };