@vaiftech/sdk-expo 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,696 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { VaifClientConfig, User, VaifClient, AuthResponse, QueryOptions, WhereFilter, OrderByClause, DbOperation, SubscriptionFilter, DbChangeEvent, ConnectionState, PresenceState, PresenceEntry, UploadResult, FileMetadata, RetryConfig, VaifFunction } from '@vaif/client';
+export { AuthResponse, ConnectionState, DbChangeEvent, DbOperation, FileMetadata, InvokeResult, OrderByClause, PresenceState, QueryOptions, UploadResult, User, VaifClient, VaifClientConfig, VaifFunction, WhereFilter } from '@vaif/client';
+
+/**
+ * Storage interface for React Native (AsyncStorage compatible)
+ */
+interface AsyncStorageInterface {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+interface VaifContextValue {
+    /** The VAIF client instance */
+    client: VaifClient;
+    /** Current authenticated user (null if not authenticated) */
+    user: User | null;
+    /** Current access token */
+    token: string | null;
+    /** Whether authentication is being checked */
+    isLoading: boolean;
+    /** Whether user is authenticated */
+    isAuthenticated: boolean;
+    /** Sign in with email/password */
+    signIn: (email: string, password: string) => Promise<AuthResponse>;
+    /** Sign up with email/password */
+    signUp: (email: string, password: string, metadata?: Record<string, unknown>) => Promise<AuthResponse>;
+    /** Sign out the current user */
+    signOut: () => Promise<void>;
+    /** Refresh the session */
+    refreshSession: () => Promise<void>;
+    /** Update the current user in state */
+    updateUser: (updates: Partial<User>) => void;
+}
+interface VaifProviderProps {
+    /** VAIF client configuration */
+    config: VaifClientConfig;
+    /** Child components */
+    children: ReactNode;
+    /** AsyncStorage instance (from @react-native-async-storage/async-storage) */
+    storage?: AsyncStorageInterface;
+    /** Callback when auth state changes */
+    onAuthStateChange?: (user: User | null) => void;
+    /** Auto refresh session before expiry (default: true) */
+    autoRefreshSession?: boolean;
+    /** Storage key for session persistence (default: 'vaif-auth') */
+    storageKey?: string;
+}
+declare function VaifProvider({ config, children, storage, onAuthStateChange, autoRefreshSession, storageKey, }: VaifProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Access the VAIF context
+ *
+ * @throws Error if used outside VaifProvider
+ */
+declare function useVaif(): VaifContextValue;
+/**
+ * Access only the VAIF client (lightweight alternative to useVaif)
+ */
+declare function useVaifClient(): VaifClient;
+
+interface UseAuthReturn {
+    user: User | null;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    token: string | null;
+    signIn: (email: string, password: string) => Promise<AuthResponse>;
+    signUp: (email: string, password: string, metadata?: Record<string, unknown>) => Promise<AuthResponse>;
+    signOut: () => Promise<void>;
+    refreshSession: () => Promise<void>;
+    updateProfile: (updates: Record<string, unknown>) => Promise<User>;
+    changePassword: (currentPassword: string, newPassword: string) => Promise<void>;
+}
+/**
+ * Hook for authentication
+ *
+ * @example
+ * ```tsx
+ * function LoginScreen() {
+ *   const { signIn, isLoading, user } = useAuth();
+ *
+ *   const handleLogin = async () => {
+ *     await signIn('user@example.com', 'password');
+ *   };
+ *
+ *   if (user) {
+ *     return <Text>Welcome, {user.email}!</Text>;
+ *   }
+ *
+ *   return (
+ *     <Button onPress={handleLogin} disabled={isLoading}>
+ *       {isLoading ? 'Signing in...' : 'Sign In'}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useAuth(): UseAuthReturn;
+/**
+ * Hook to get just the current user
+ */
+declare function useUser(): User | null;
+
+type QueryStatus = "idle" | "loading" | "success" | "error";
+interface UseQueryOptions extends Omit<QueryOptions, "where" | "orderBy"> {
+    /** Where conditions */
+    where?: WhereFilter | WhereFilter[];
+    /** Order by clauses */
+    orderBy?: OrderByClause | OrderByClause[];
+    /** Skip fetching */
+    enabled?: boolean;
+    /** Refetch interval in ms */
+    refetchInterval?: number;
+}
+interface UseQueryReturn<T> {
+    data: T[];
+    status: QueryStatus;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface UsePaginatedQueryOptions extends UseQueryOptions {
+    pageSize?: number;
+    initialPage?: number;
+}
+interface UsePaginatedQueryReturn<T> extends UseQueryReturn<T> {
+    page: number;
+    pageSize: number;
+    totalPages: number;
+    totalCount: number;
+    hasNextPage: boolean;
+    hasPreviousPage: boolean;
+    nextPage: () => void;
+    previousPage: () => void;
+    goToPage: (page: number) => void;
+}
+/**
+ * Hook for querying data from a table
+ *
+ * @example
+ * ```tsx
+ * function TaskList() {
+ *   const { data: tasks, isLoading, error, refetch } = useQuery<Task>('tasks', {
+ *     where: { status: 'active' },
+ *     orderBy: { column: 'created_at', direction: 'desc' },
+ *     limit: 20,
+ *   });
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *   if (error) return <Text>Error: {error.message}</Text>;
+ *
+ *   return (
+ *     <FlatList
+ *       data={tasks}
+ *       keyExtractor={(item) => item.id}
+ *       renderItem={({ item }) => <TaskItem task={item} />}
+ *       onRefresh={refetch}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+declare function useQuery<T extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: UseQueryOptions): UseQueryReturn<T>;
+/**
+ * Hook for fetching a single record by ID
+ */
+declare function useQueryById<T extends Record<string, unknown> = Record<string, unknown>>(table: string, id: string | undefined, options?: {
+    enabled?: boolean;
+}): {
+    data: T | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook for paginated queries
+ */
+declare function usePaginatedQuery<T extends Record<string, unknown> = Record<string, unknown>>(table: string, options?: UsePaginatedQueryOptions): UsePaginatedQueryReturn<T>;
+
+type MutationStatus = "idle" | "loading" | "success" | "error";
+interface UseMutationReturn<T, TInput = Partial<T>> {
+    mutate: (input: TInput) => Promise<T | null>;
+    data: T | null;
+    status: MutationStatus;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+interface UseCreateReturn<T> extends UseMutationReturn<T, Partial<T>> {
+    create: (data: Partial<T>) => Promise<T | null>;
+}
+interface UseUpdateReturn<T> {
+    update: (id: string, data: Partial<T>) => Promise<T | null>;
+    data: T | null;
+    status: MutationStatus;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+interface UseDeleteReturn {
+    remove: (id: string) => Promise<boolean>;
+    status: MutationStatus;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+interface UseUpsertReturn<T> {
+    upsert: (data: Partial<T>, conflictFields: string[]) => Promise<T | null>;
+    data: T | null;
+    status: MutationStatus;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    reset: () => void;
+}
+/**
+ * Hook for creating records
+ *
+ * @example
+ * ```tsx
+ * function CreateTask() {
+ *   const { create, isLoading, error } = useCreate<Task>('tasks');
+ *
+ *   const handleCreate = async () => {
+ *     const task = await create({ title: 'New Task', status: 'pending' });
+ *     if (task) {
+ *       console.log('Created:', task.id);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <Button onPress={handleCreate} disabled={isLoading}>
+ *       Create Task
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useCreate<T extends Record<string, unknown> = Record<string, unknown>>(table: string): UseCreateReturn<T>;
+/**
+ * Hook for updating records
+ *
+ * @example
+ * ```tsx
+ * function UpdateTask({ taskId }: { taskId: string }) {
+ *   const { update, isLoading } = useUpdate<Task>('tasks');
+ *
+ *   const handleComplete = async () => {
+ *     await update(taskId, { status: 'completed' });
+ *   };
+ *
+ *   return (
+ *     <Button onPress={handleComplete} disabled={isLoading}>
+ *       Mark Complete
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useUpdate<T extends Record<string, unknown> = Record<string, unknown>>(table: string): UseUpdateReturn<T>;
+/**
+ * Hook for deleting records
+ *
+ * @example
+ * ```tsx
+ * function DeleteTask({ taskId }: { taskId: string }) {
+ *   const { remove, isLoading } = useDelete('tasks');
+ *
+ *   const handleDelete = async () => {
+ *     const success = await remove(taskId);
+ *     if (success) {
+ *       console.log('Deleted!');
+ *     }
+ *   };
+ *
+ *   return (
+ *     <Button onPress={handleDelete} disabled={isLoading}>
+ *       Delete
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useDelete(table: string): UseDeleteReturn;
+/**
+ * Hook for upserting records
+ *
+ * @example
+ * ```tsx
+ * function UpsertUser({ userId }: { userId: string }) {
+ *   const { upsert, isLoading } = useUpsert<User>('users');
+ *
+ *   const handleUpsert = async () => {
+ *     await upsert(
+ *       { id: userId, name: 'John', email: 'john@example.com' },
+ *       ['id']
+ *     );
+ *   };
+ *
+ *   return (
+ *     <Button onPress={handleUpsert} disabled={isLoading}>
+ *       Save
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useUpsert<T extends Record<string, unknown> = Record<string, unknown>>(table: string): UseUpsertReturn<T>;
+/**
+ * Hook for batch creating records
+ */
+declare function useBatchCreate<T extends Record<string, unknown> = Record<string, unknown>>(table: string): {
+    createMany: (items: Partial<T>[]) => Promise<T[]>;
+    data: T[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+};
+
+interface UseSubscriptionOptions<T> {
+    /** Filter by operation type */
+    event?: DbOperation | DbOperation[];
+    /** Filter condition */
+    filter?: SubscriptionFilter | SubscriptionFilter[];
+    /** Callback when record is inserted */
+    onInsert?: (record: T) => void;
+    /** Callback when record is updated */
+    onUpdate?: (record: T, old: T | null) => void;
+    /** Callback when record is deleted */
+    onDelete?: (old: T) => void;
+    /** Callback for any change */
+    onChange?: (event: DbChangeEvent<T>) => void;
+    /** Skip subscription */
+    enabled?: boolean;
+}
+interface UseSubscriptionReturn {
+    isConnected: boolean;
+    connectionState: ConnectionState;
+    unsubscribe: () => void;
+}
+interface UsePresenceOptions<T extends PresenceState> {
+    /** Initial presence state */
+    initialState?: T;
+}
+interface UsePresenceReturn<T extends PresenceState> {
+    /** Current presence state for all users */
+    presences: PresenceEntry<T>[];
+    /** Track your own presence */
+    track: (state: T) => void;
+    /** Update your presence */
+    update: (state: Partial<T>) => void;
+    /** Untrack your presence */
+    untrack: () => void;
+    /** Connection state */
+    isConnected: boolean;
+}
+interface UseBroadcastReturn<T> {
+    /** Send a broadcast message */
+    broadcast: (event: string, payload: T) => void;
+    /** Last received message */
+    lastMessage: {
+        event: string;
+        payload: T;
+    } | null;
+    /** Subscribe to specific event */
+    subscribe: (event: string, handler: (payload: T) => void) => () => void;
+    /** Connection state */
+    isConnected: boolean;
+}
+/**
+ * Hook for realtime database subscriptions
+ *
+ * @example
+ * ```tsx
+ * function TaskList() {
+ *   const [tasks, setTasks] = useState<Task[]>([]);
+ *
+ *   useSubscription<Task>('tasks', {
+ *     onInsert: (task) => setTasks(prev => [...prev, task]),
+ *     onUpdate: (task) => setTasks(prev =>
+ *       prev.map(t => t.id === task.id ? task : t)
+ *     ),
+ *     onDelete: (task) => setTasks(prev =>
+ *       prev.filter(t => t.id !== task.id)
+ *     ),
+ *   });
+ *
+ *   return <FlatList data={tasks} ... />;
+ * }
+ * ```
+ */
+declare function useSubscription<T = unknown>(table: string, options?: UseSubscriptionOptions<T>): UseSubscriptionReturn;
+/**
+ * Hook for presence tracking
+ *
+ * @example
+ * ```tsx
+ * function OnlineUsers() {
+ *   const { presences, track } = usePresence<{ name: string; status: string }>('room-1');
+ *
+ *   useEffect(() => {
+ *     track({ name: 'John', status: 'online' });
+ *   }, []);
+ *
+ *   return (
+ *     <View>
+ *       {presences.map((p) => (
+ *         <Text key={p.connectionId}>{p.state.name}: {p.state.status}</Text>
+ *       ))}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function usePresence<T extends PresenceState = PresenceState>(channelName: string, options?: UsePresenceOptions<T>): UsePresenceReturn<T>;
+/**
+ * Hook for broadcast messaging
+ *
+ * @example
+ * ```tsx
+ * function Chat() {
+ *   const { broadcast, subscribe } = useBroadcast<{ text: string }>('chat-room');
+ *   const [messages, setMessages] = useState<string[]>([]);
+ *
+ *   useEffect(() => {
+ *     const unsubscribe = subscribe('message', (payload) => {
+ *       setMessages(prev => [...prev, payload.text]);
+ *     });
+ *     return unsubscribe;
+ *   }, [subscribe]);
+ *
+ *   const sendMessage = (text: string) => {
+ *     broadcast('message', { text });
+ *   };
+ *
+ *   return <ChatUI messages={messages} onSend={sendMessage} />;
+ * }
+ * ```
+ */
+declare function useBroadcast<T = unknown>(channelName: string): UseBroadcastReturn<T>;
+/**
+ * Hook for realtime connection state
+ */
+declare function useRealtimeConnection(): {
+    connectionState: ConnectionState;
+    isConnected: boolean;
+    reconnect: () => void;
+    disconnect: () => void;
+};
+
+interface UseUploadReturn {
+    upload: (file: Blob | ArrayBuffer, path: string, options?: UploadOptions) => Promise<UploadResult | null>;
+    uploadUri: (uri: string, path: string, options?: UploadOptions) => Promise<UploadResult | null>;
+    progress: number;
+    isUploading: boolean;
+    isError: boolean;
+    error: Error | null;
+    result: UploadResult | null;
+    reset: () => void;
+}
+interface UploadOptions {
+    bucket?: string;
+    contentType?: string;
+    metadata?: Record<string, string>;
+    isPublic?: boolean;
+}
+interface UseDownloadReturn {
+    download: (path: string) => Promise<Blob | null>;
+    isDownloading: boolean;
+    isError: boolean;
+    error: Error | null;
+    progress: number;
+}
+interface UseFileReturn {
+    file: FileMetadata | null;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    remove: () => Promise<boolean>;
+}
+interface UseFilesReturn {
+    files: FileMetadata[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for file uploads
+ *
+ * @example
+ * ```tsx
+ * import * as ImagePicker from 'expo-image-picker';
+ *
+ * function ImageUpload() {
+ *   const { uploadUri, isUploading, progress } = useUpload();
+ *
+ *   const pickAndUpload = async () => {
+ *     const result = await ImagePicker.launchImageLibraryAsync();
+ *     if (!result.canceled) {
+ *       const { uri } = result.assets[0];
+ *       await uploadUri(uri, `photos/${Date.now()}.jpg`);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Button onPress={pickAndUpload} disabled={isUploading}>
+ *         {isUploading ? `Uploading ${progress}%` : 'Select Image'}
+ *       </Button>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useUpload(defaultBucket?: string): UseUploadReturn;
+/**
+ * Hook for file downloads
+ *
+ * @example
+ * ```tsx
+ * function FileDownload({ path }: { path: string }) {
+ *   const { download, isDownloading, progress } = useDownload();
+ *
+ *   const handleDownload = async () => {
+ *     const blob = await download(path);
+ *     if (blob) {
+ *       // Handle the blob (e.g., save or display)
+ *     }
+ *   };
+ *
+ *   return (
+ *     <Button onPress={handleDownload} disabled={isDownloading}>
+ *       {isDownloading ? `${progress}%` : 'Download'}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useDownload(defaultBucket?: string): UseDownloadReturn;
+/**
+ * Hook for fetching file metadata
+ */
+declare function useFile(path: string | undefined, options?: {
+    bucket?: string;
+}): UseFileReturn;
+/**
+ * Hook for listing files
+ */
+declare function useFiles(options?: {
+    bucket?: string;
+    prefix?: string;
+    limit?: number;
+}): UseFilesReturn;
+/**
+ * Hook for getting public URL
+ */
+declare function usePublicUrl(path: string | undefined, options?: {
+    bucket?: string;
+}): string | null;
+
+interface UseFunctionOptions {
+    /** Retry configuration */
+    retry?: RetryConfig;
+    /** Timeout in ms */
+    timeout?: number;
+    /** Skip invoking */
+    enabled?: boolean;
+}
+interface UseFunctionReturn<TOutput, TInput = unknown> {
+    invoke: (input?: TInput) => Promise<TOutput | null>;
+    data: TOutput | null;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+    reset: () => void;
+    /** Execution metadata */
+    meta: {
+        status?: number;
+        durationMs?: number;
+        requestId?: string;
+        logs?: string[];
+    } | null;
+}
+interface UseRpcReturn<TOutput, TInput = unknown> extends UseFunctionReturn<TOutput, TInput> {
+    call: (input?: TInput) => Promise<TOutput | null>;
+}
+interface UseFunctionListReturn {
+    functions: VaifFunction[];
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook for invoking serverless functions
+ *
+ * @example
+ * ```tsx
+ * function SendEmail() {
+ *   const { invoke, isLoading, error } = useFunction<{ success: boolean }, { to: string; subject: string }>('send-email');
+ *
+ *   const handleSend = async () => {
+ *     const result = await invoke({
+ *       to: 'user@example.com',
+ *       subject: 'Hello!',
+ *     });
+ *     if (result?.success) {
+ *       Alert.alert('Email sent!');
+ *     }
+ *   };
+ *
+ *   return (
+ *     <Button onPress={handleSend} disabled={isLoading}>
+ *       {isLoading ? 'Sending...' : 'Send Email'}
+ *     </Button>
+ *   );
+ * }
+ * ```
+ */
+declare function useFunction<TOutput = unknown, TInput = unknown>(functionId: string, options?: UseFunctionOptions): UseFunctionReturn<TOutput, TInput>;
+/**
+ * Hook for RPC-style function calls (alias for useFunction)
+ *
+ * @example
+ * ```tsx
+ * function Calculator() {
+ *   const { call, data, isLoading } = useRpc<{ result: number }, { a: number; b: number }>('add-numbers');
+ *
+ *   const handleAdd = async () => {
+ *     const result = await call({ a: 5, b: 3 });
+ *     console.log('Sum:', result?.result); // 8
+ *   };
+ *
+ *   return (
+ *     <View>
+ *       <Text>Result: {data?.result ?? '-'}</Text>
+ *       <Button onPress={handleAdd} disabled={isLoading}>Add</Button>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useRpc<TOutput = unknown, TInput = unknown>(functionId: string, options?: UseFunctionOptions): UseRpcReturn<TOutput, TInput>;
+/**
+ * Hook for auto-invoking a function on mount
+ *
+ * @example
+ * ```tsx
+ * function UserStats() {
+ *   const { data, isLoading, refetch } = useFunctionQuery<Stats>('get-user-stats');
+ *
+ *   if (isLoading) return <ActivityIndicator />;
+ *
+ *   return (
+ *     <View>
+ *       <Text>Posts: {data?.posts}</Text>
+ *       <Text>Followers: {data?.followers}</Text>
+ *       <Button onPress={refetch}>Refresh</Button>
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+declare function useFunctionQuery<TOutput = unknown, TInput = unknown>(functionId: string, input?: TInput, options?: UseFunctionOptions & {
+    refetchInterval?: number;
+}): UseFunctionReturn<TOutput, TInput> & {
+    refetch: () => Promise<void>;
+};
+/**
+ * Hook for listing available functions
+ */
+declare function useFunctionList(projectId: string, options?: {
+    envId?: string;
+    enabled?: boolean;
+}): UseFunctionListReturn;
+/**
+ * Hook for batch invoking multiple functions
+ */
+declare function useBatchInvoke<TOutput = unknown>(): {
+    invoke: (functionIds: string[], inputs?: unknown[]) => Promise<(TOutput | null)[]>;
+    results: (TOutput | null)[];
+    isLoading: boolean;
+    errors: (Error | null)[];
+};
+
+export { type AsyncStorageInterface, type MutationStatus, type QueryStatus, type UploadOptions, type UseAuthReturn, type UseBroadcastReturn, type UseCreateReturn, type UseDeleteReturn, type UseDownloadReturn, type UseFileReturn, type UseFilesReturn, type UseFunctionListReturn, type UseFunctionOptions, type UseFunctionReturn, type UseMutationReturn, type UsePaginatedQueryOptions, type UsePaginatedQueryReturn, type UsePresenceOptions, type UsePresenceReturn, type UseQueryOptions, type UseQueryReturn, type UseRpcReturn, type UseSubscriptionOptions, type UseSubscriptionReturn, type UseUpdateReturn, type UseUploadReturn, type UseUpsertReturn, type VaifContextValue, VaifProvider, type VaifProviderProps, useAuth, useBatchCreate, useBatchInvoke, useBroadcast, useCreate, useDelete, useDownload, useFile, useFiles, useFunction, useFunctionList, useFunctionQuery, usePaginatedQuery, usePresence, usePublicUrl, useQuery, useQueryById, useRealtimeConnection, useRpc, useSubscription, useUpdate, useUpload, useUpsert, useUser, useVaif, useVaifClient };