@objectstack/client-react 1.0.4 → 1.0.5

package/.turbo/turbo-build.log

@@ -0,0 +1,22 @@
+
+> @objectstack/client-react@1.0.5 build /home/runner/work/spec/spec/packages/client-react
+> tsup src/index.tsx --config ../../tsup.config.ts
+
+CLI Building entry: src/index.tsx
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /home/runner/work/spec/spec/tsup.config.ts
+CLI Target: es2020
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist/index.mjs     12.47 KB
+ESM dist/index.mjs.map 35.40 KB
+ESM ⚡️ Build success in 49ms
+CJS dist/index.js     15.27 KB
+CJS dist/index.js.map 35.43 KB
+CJS ⚡️ Build success in 49ms
+DTS Build start
+DTS ⚡️ Build success in 10112ms
+DTS dist/index.d.mts 11.92 KB
+DTS dist/index.d.ts  11.92 KB

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @objectstack/client-react
 
+## 1.0.5
+
+### Patch Changes
+
+- b1d24bd: refactor: migrate build system from tsc to tsup for faster builds
+  - Replaced `tsc` with `tsup` (using esbuild) across all packages
+  - Added shared `tsup.config.ts` in workspace root
+  - Added `tsup` as workspace dev dependency
+  - significantly improved build performance
+- 877b864: fix: add SPA fallback to hono, fix msw context binding, improve runtime resilience, and fix client-react build types
+- Updated dependencies [b1d24bd]
+  - @objectstack/core@1.0.5
+  - @objectstack/client@1.0.5
+  - @objectstack/spec@1.0.5
+
 ## 1.0.4
 
 ### Patch Changes

package/dist/index.d.mts

@@ -0,0 +1,416 @@
+import * as React from 'react';
+import { ReactNode } from 'react';
+import { ObjectStackClient, PaginatedResult } from '@objectstack/client';
+export { ClientConfig, ObjectStackClient } from '@objectstack/client';
+import { QueryAST, FilterCondition } from '@objectstack/spec/data';
+
+/**
+ * ObjectStack React Context
+ *
+ * Provides ObjectStackClient instance to React components via Context API
+ */
+
+interface ObjectStackProviderProps {
+    client: ObjectStackClient;
+    children: ReactNode;
+}
+declare const ObjectStackContext: React.Context<ObjectStackClient | null>;
+/**
+ * Provider component that makes ObjectStackClient available to all child components
+ *
+ * @example
+ * ```tsx
+ * const client = new ObjectStackClient({ baseUrl: 'http://localhost:3000' });
+ *
+ * function App() {
+ *   return (
+ *     <ObjectStackProvider client={client}>
+ *       <YourComponents />
+ *     </ObjectStackProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function ObjectStackProvider({ client, children }: ObjectStackProviderProps): React.JSX.Element;
+/**
+ * Hook to access the ObjectStackClient instance from context
+ *
+ * @throws Error if used outside of ObjectStackProvider
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const client = useClient();
+ *   // Use client.data.find(), etc.
+ * }
+ * ```
+ */
+declare function useClient(): ObjectStackClient;
+
+/**
+ * Data Query Hooks
+ *
+ * React hooks for querying and mutating ObjectStack data
+ */
+
+/**
+ * Query options for useQuery hook
+ */
+interface UseQueryOptions<T = any> {
+    /** Query AST or simplified query options */
+    query?: Partial<QueryAST>;
+    /** Simple field selection */
+    select?: string[];
+    /** Simple filters */
+    filters?: FilterCondition;
+    /** Sort configuration */
+    sort?: string | string[];
+    /** Limit results */
+    top?: number;
+    /** Skip results (for pagination) */
+    skip?: number;
+    /** Enable/disable automatic query execution */
+    enabled?: boolean;
+    /** Refetch interval in milliseconds */
+    refetchInterval?: number;
+    /** Callback on successful query */
+    onSuccess?: (data: PaginatedResult<T>) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Query result for useQuery hook
+ */
+interface UseQueryResult<T = any> {
+    /** Query result data */
+    data: PaginatedResult<T> | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch the query */
+    refetch: () => Promise<void>;
+    /** Is currently refetching */
+    isRefetching: boolean;
+}
+/**
+ * Hook for querying ObjectStack data with automatic caching and refetching
+ *
+ * @example
+ * ```tsx
+ * function TaskList() {
+ *   const { data, isLoading, error, refetch } = useQuery('todo_task', {
+ *     select: ['id', 'subject', 'priority'],
+ *     sort: ['-created_at'],
+ *     top: 20
+ *   });
+ *
+ *   if (isLoading) return <div>Loading...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *
+ *   return (
+ *     <div>
+ *       {data?.value.map(task => (
+ *         <div key={task.id}>{task.subject}</div>
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useQuery<T = any>(object: string, options?: UseQueryOptions<T>): UseQueryResult<T>;
+/**
+ * Mutation options for useMutation hook
+ */
+interface UseMutationOptions<TData = any, TVariables = any> {
+    /** Callback on successful mutation */
+    onSuccess?: (data: TData, variables: TVariables) => void;
+    /** Callback on error */
+    onError?: (error: Error, variables: TVariables) => void;
+    /** Callback when mutation is settled (success or error) */
+    onSettled?: (data: TData | undefined, error: Error | null, variables: TVariables) => void;
+}
+/**
+ * Mutation result for useMutation hook
+ */
+interface UseMutationResult<TData = any, TVariables = any> {
+    /** Execute the mutation */
+    mutate: (variables: TVariables) => Promise<TData>;
+    /** Async version of mutate that throws errors */
+    mutateAsync: (variables: TVariables) => Promise<TData>;
+    /** Mutation result data */
+    data: TData | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Reset mutation state */
+    reset: () => void;
+}
+/**
+ * Hook for creating, updating, or deleting ObjectStack data
+ *
+ * @example
+ * ```tsx
+ * function CreateTaskForm() {
+ *   const { mutate, isLoading, error } = useMutation('todo_task', 'create', {
+ *     onSuccess: (data) => {
+ *       console.log('Task created:', data);
+ *     }
+ *   });
+ *
+ *   const handleSubmit = (formData) => {
+ *     mutate(formData);
+ *   };
+ *
+ *   return <form onSubmit={handleSubmit}>...</form>;
+ * }
+ * ```
+ */
+declare function useMutation<TData = any, TVariables = any>(object: string, operation: 'create' | 'update' | 'delete' | 'createMany' | 'updateMany' | 'deleteMany', options?: UseMutationOptions<TData, TVariables>): UseMutationResult<TData, TVariables>;
+/**
+ * Pagination options for usePagination hook
+ */
+interface UsePaginationOptions<T = any> extends Omit<UseQueryOptions<T>, 'top' | 'skip'> {
+    /** Page size */
+    pageSize?: number;
+    /** Initial page (1-based) */
+    initialPage?: number;
+}
+/**
+ * Pagination result for usePagination hook
+ */
+interface UsePaginationResult<T = any> extends UseQueryResult<T> {
+    /** Current page (1-based) */
+    page: number;
+    /** Total number of pages */
+    totalPages: number;
+    /** Total number of records */
+    totalCount: number;
+    /** Go to next page */
+    nextPage: () => void;
+    /** Go to previous page */
+    previousPage: () => void;
+    /** Go to specific page */
+    goToPage: (page: number) => void;
+    /** Whether there is a next page */
+    hasNextPage: boolean;
+    /** Whether there is a previous page */
+    hasPreviousPage: boolean;
+}
+/**
+ * Hook for paginated data queries
+ *
+ * @example
+ * ```tsx
+ * function PaginatedTaskList() {
+ *   const {
+ *     data,
+ *     isLoading,
+ *     page,
+ *     totalPages,
+ *     nextPage,
+ *     previousPage,
+ *     hasNextPage,
+ *     hasPreviousPage
+ *   } = usePagination('todo_task', {
+ *     pageSize: 10,
+ *     sort: ['-created_at']
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {data?.value.map(task => <div key={task.id}>{task.subject}</div>)}
+ *       <button onClick={previousPage} disabled={!hasPreviousPage}>Previous</button>
+ *       <span>Page {page} of {totalPages}</span>
+ *       <button onClick={nextPage} disabled={!hasNextPage}>Next</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function usePagination<T = any>(object: string, options?: UsePaginationOptions<T>): UsePaginationResult<T>;
+/**
+ * Infinite query options for useInfiniteQuery hook
+ */
+interface UseInfiniteQueryOptions<T = any> extends Omit<UseQueryOptions<T>, 'skip'> {
+    /** Page size for each fetch */
+    pageSize?: number;
+    /** Get next page parameter */
+    getNextPageParam?: (lastPage: PaginatedResult<T>, allPages: PaginatedResult<T>[]) => number | undefined;
+}
+/**
+ * Infinite query result for useInfiniteQuery hook
+ */
+interface UseInfiniteQueryResult<T = any> {
+    /** All pages of data */
+    data: PaginatedResult<T>[];
+    /** Flattened data from all pages */
+    flatData: T[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Load the next page */
+    fetchNextPage: () => Promise<void>;
+    /** Whether there are more pages */
+    hasNextPage: boolean;
+    /** Is currently fetching next page */
+    isFetchingNextPage: boolean;
+    /** Refetch all pages */
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for infinite scrolling / load more functionality
+ *
+ * @example
+ * ```tsx
+ * function InfiniteTaskList() {
+ *   const {
+ *     flatData,
+ *     isLoading,
+ *     fetchNextPage,
+ *     hasNextPage,
+ *     isFetchingNextPage
+ *   } = useInfiniteQuery('todo_task', {
+ *     pageSize: 20,
+ *     sort: ['-created_at']
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {flatData.map(task => <div key={task.id}>{task.subject}</div>)}
+ *       {hasNextPage && (
+ *         <button onClick={fetchNextPage} disabled={isFetchingNextPage}>
+ *           {isFetchingNextPage ? 'Loading...' : 'Load More'}
+ *         </button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useInfiniteQuery<T = any>(object: string, options?: UseInfiniteQueryOptions<T>): UseInfiniteQueryResult<T>;
+
+/**
+ * Metadata Hooks
+ *
+ * React hooks for accessing ObjectStack metadata (schemas, views, fields)
+ */
+
+/**
+ * Metadata query options
+ */
+interface UseMetadataOptions {
+    /** Enable/disable automatic query execution */
+    enabled?: boolean;
+    /** Use cached metadata if available */
+    useCache?: boolean;
+    /** ETag for conditional requests */
+    ifNoneMatch?: string;
+    /** If-Modified-Since header for conditional requests */
+    ifModifiedSince?: string;
+    /** Callback on successful query */
+    onSuccess?: (data: any) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Metadata query result
+ */
+interface UseMetadataResult<T = any> {
+    /** Metadata data */
+    data: T | null;
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Refetch the metadata */
+    refetch: () => Promise<void>;
+    /** ETag from last fetch */
+    etag?: string;
+    /** Whether data came from cache (304 Not Modified) */
+    fromCache: boolean;
+}
+/**
+ * Hook for fetching object schema/metadata
+ *
+ * @example
+ * ```tsx
+ * function ObjectSchemaViewer({ objectName }: { objectName: string }) {
+ *   const { data: schema, isLoading, error } = useObject(objectName);
+ *
+ *   if (isLoading) return <div>Loading schema...</div>;
+ *   if (error) return <div>Error: {error.message}</div>;
+ *
+ *   return (
+ *     <div>
+ *       <h2>{schema.label}</h2>
+ *       <p>Fields: {Object.keys(schema.fields).length}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useObject(objectName: string, options?: UseMetadataOptions): UseMetadataResult;
+/**
+ * Hook for fetching view configuration
+ *
+ * @example
+ * ```tsx
+ * function ViewConfiguration({ objectName }: { objectName: string }) {
+ *   const { data: view, isLoading } = useView(objectName, 'list');
+ *
+ *   if (isLoading) return <div>Loading view...</div>;
+ *
+ *   return (
+ *     <div>
+ *       <h3>List View for {objectName}</h3>
+ *       <p>Columns: {view?.columns?.length}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useView(objectName: string, viewType?: 'list' | 'form', options?: UseMetadataOptions): UseMetadataResult;
+/**
+ * Hook for extracting fields from object schema
+ *
+ * @example
+ * ```tsx
+ * function FieldList({ objectName }: { objectName: string }) {
+ *   const { data: fields, isLoading } = useFields(objectName);
+ *
+ *   if (isLoading) return <div>Loading fields...</div>;
+ *
+ *   return (
+ *     <ul>
+ *       {fields?.map(field => (
+ *         <li key={field.name}>{field.label} ({field.type})</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ * ```
+ */
+declare function useFields(objectName: string, options?: UseMetadataOptions): UseMetadataResult<any[]>;
+/**
+ * Generic metadata hook for custom metadata queries
+ *
+ * @example
+ * ```tsx
+ * function CustomMetadata() {
+ *   const { data, isLoading } = useMetadata(async (client) => {
+ *     // Custom metadata fetching logic
+ *     const object = await client.meta.getObject('custom_object');
+ *     const view = await client.meta.getView('custom_object', 'list');
+ *     return { object, view };
+ *   });
+ *
+ *   return <pre>{JSON.stringify(data, null, 2)}</pre>;
+ * }
+ * ```
+ */
+declare function useMetadata<T = any>(fetcher: (client: ReturnType<typeof useClient>) => Promise<T>, options?: Omit<UseMetadataOptions, 'useCache' | 'ifNoneMatch' | 'ifModifiedSince'>): UseMetadataResult<T>;
+
+export { ObjectStackContext, ObjectStackProvider, type ObjectStackProviderProps, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMetadataOptions, type UseMetadataResult, type UseMutationOptions, type UseMutationResult, type UsePaginationOptions, type UsePaginationResult, type UseQueryOptions, type UseQueryResult, useClient, useFields, useInfiniteQuery, useMetadata, useMutation, useObject, usePagination, useQuery, useView };