dynamodb-reactive 0.1.22 → 0.2.1

package/dist/react-D_NLHuuO.d.ts

@@ -1,556 +0,0 @@
-import * as react_jsx_runtime from 'react/jsx-runtime';
-import { ReactNode } from 'react';
-
-/**
- * JSON Patch operation (RFC 6902)
- */
-interface JsonPatch {
-    op: 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
-    path: string;
-    value?: unknown;
-    from?: string;
-}
-/**
- * Messages sent from client to server
- */
-interface SubscribeMessage {
-    type: 'subscribe';
-    subscriptionId: string;
-    path: string;
-    input: unknown;
-}
-interface UnsubscribeMessage {
-    type: 'unsubscribe';
-    subscriptionId: string;
-}
-interface CallMessage {
-    type: 'call';
-    callId: string;
-    path: string;
-    input: unknown;
-}
-interface InitMessage {
-    type: 'init';
-}
-interface PingMessage {
-    type: 'ping';
-}
-type ClientMessage = InitMessage | PingMessage | SubscribeMessage | UnsubscribeMessage | CallMessage;
-/**
- * Messages sent from server to client
- */
-interface ConnectedMessage {
-    type: 'connected';
-    connectionId: string;
-}
-interface SnapshotMessage {
-    type: 'snapshot';
-    subscriptionId: string;
-    data: unknown;
-}
-interface PatchMessage {
-    type: 'patch';
-    subscriptionId: string;
-    patches: JsonPatch[];
-}
-interface ResultMessage {
-    type: 'result';
-    callId: string;
-    data: unknown;
-}
-interface ErrorMessage {
-    type: 'error';
-    message: string;
-    subscriptionId?: string;
-    callId?: string;
-}
-interface PongMessage {
-    type: 'pong';
-}
-type ServerMessage = ConnectedMessage | PongMessage | SnapshotMessage | PatchMessage | ResultMessage | ErrorMessage;
-/**
- * Client configuration
- */
-interface ReactiveClientConfig {
-    /**
-     * WebSocket URL to connect to
-     */
-    url: string;
-    /**
-     * HTTP URL for subscribe/call requests.
-     * Defaults to '/api/reactive' for Next.js apps.
-     */
-    httpUrl?: string;
-    /**
-     * Authentication token or getter function
-     */
-    auth?: string | (() => string | Promise<string>);
-    /**
-     * Custom headers to send with HTTP requests.
-     * Can be a static object or a getter function for dynamic headers.
-     * Useful for passing auth tokens or user context to the server.
-     */
-    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
-    /**
-     * Enable automatic reconnection
-     * @default true
-     */
-    autoReconnect?: boolean;
-    /**
-     * Reconnection delay in milliseconds
-     * @default 1000
-     */
-    reconnectDelay?: number;
-    /**
-     * Maximum reconnection attempts
-     * @default 10
-     */
-    maxReconnectAttempts?: number;
-    /**
-     * Callback when connected
-     */
-    onConnect?: () => void;
-    /**
-     * Callback when disconnected
-     */
-    onDisconnect?: () => void;
-    /**
-     * Callback for errors
-     */
-    onError?: (error: Error) => void;
-}
-/**
- * Subscription options
- */
-interface SubscriptionOptions<TInput> {
-    /**
-     * Input for the subscription
-     */
-    input?: TInput;
-    /**
-     * Whether to automatically resubscribe on reconnect
-     * @default true
-     */
-    resubscribeOnReconnect?: boolean;
-    /**
-     * Callback when data is received
-     */
-    onData?: (data: unknown) => void;
-    /**
-     * Callback when an error occurs
-     */
-    onError?: (error: Error) => void;
-}
-/**
- * Active subscription
- */
-interface Subscription<TData> {
-    /**
-     * Subscription ID (used for registering listeners)
-     */
-    id: string;
-    /**
-     * Current data
-     */
-    data: TData | undefined;
-    /**
-     * Whether the subscription is loading
-     */
-    loading: boolean;
-    /**
-     * Error if any
-     */
-    error: Error | undefined;
-    /**
-     * Unsubscribe from updates
-     */
-    unsubscribe: () => void;
-    /**
-     * Manually refetch the data
-     */
-    refetch: () => Promise<void>;
-}
-/**
- * Connection state
- */
-type ConnectionState = 'connecting' | 'connected' | 'disconnected' | 'reconnecting';
-/**
- * Type helpers for inferring router types
- */
-type InferInput<T> = T extends {
-    input: infer TInput;
-} ? TInput : undefined;
-type InferOutput<T> = T extends {
-    output: infer TOutput;
-} ? TOutput : unknown;
-/**
- * Mutation options for optimistic updates
- */
-interface MutationOptions<TInput = unknown, TOutput = unknown> {
-    /**
-     * Subscription path to optimistically update (e.g., 'todos.list')
-     * If not provided, auto-detected from mutation path (e.g., 'todos.toggle' -> 'todos.list')
-     */
-    invalidates?: string;
-    /**
-     * How to apply the mutation result to subscription data (applied INSTANTLY before HTTP)
-     * - 'merge': Find item by input.id and merge input fields into it
-     * - 'remove': Remove item by input.id
-     * - Custom function for complex cases
-     */
-    optimisticUpdate?: 'merge' | 'remove' | ((currentData: unknown[], input: TInput, result?: TOutput) => unknown[]);
-    /**
-     * For create operations (no input.id), provide the optimistic item to add.
-     * Can be the item object or a function that receives input and current data.
-     */
-    optimisticData?: TOutput | ((input: TInput, currentData: unknown[]) => TOutput | undefined);
-}
-
-/**
- * Internal subscription state
- */
-interface SubscriptionState<TData> {
-    id: string;
-    path: string;
-    input: unknown;
-    data: TData | undefined;
-    loading: boolean;
-    error: Error | undefined;
-    listeners: Set<() => void>;
-    options: SubscriptionOptions<unknown>;
-}
-/**
- * Reactive client for type-safe subscriptions
- */
-declare class ReactiveClient {
-    private wsManager;
-    private httpUrl;
-    private authGetter?;
-    private headersGetter?;
-    private subscriptions;
-    private pendingCalls;
-    private connectionState;
-    private stateListeners;
-    private optimisticUpdates;
-    constructor(config: ReactiveClientConfig);
-    /**
-     * Connect to the server
-     */
-    connect(): Promise<void>;
-    /**
-     * Disconnect from the server
-     */
-    disconnect(): void;
-    /**
-     * Force reconnect - closes existing connection and reconnects
-     * Useful for recovering from stale connections
-     */
-    forceReconnect(): void;
-    /**
-     * Update the headers getter for HTTP requests.
-     * Useful for dynamically setting auth or user context headers.
-     */
-    setHeaders(headers: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>)): void;
-    /**
-     * Get current connection state
-     */
-    getConnectionState(): ConnectionState;
-    /**
-     * Subscribe to connection state changes
-     */
-    onConnectionStateChange(listener: (state: ConnectionState) => void): () => void;
-    /**
-     * Subscribe to a procedure via HTTP.
-     * Snapshot is returned via HTTP, patches come via WebSocket.
-     */
-    subscribe<TData>(path: string, options?: SubscriptionOptions<unknown>): Subscription<TData>;
-    /**
-     * Send subscribe request via HTTP
-     */
-    private sendSubscribeRequest;
-    /**
-     * Call a mutation procedure via HTTP with optimistic update support.
-     * All optimistic updates are applied INSTANTLY (before HTTP request).
-     */
-    call<TInput, TOutput>(path: string, input: TInput, options?: MutationOptions<TInput, TOutput>): Promise<TOutput>;
-    /**
-     * Unsubscribe from a subscription
-     */
-    private unsubscribe;
-    /**
-     * Refetch a subscription via HTTP
-     */
-    private refetch;
-    /**
-     * Handle incoming server messages.
-     * Note: 'connected' messages are handled by WebSocketManager before reaching here.
-     */
-    private handleMessage;
-    /**
-     * Handle a snapshot message
-     */
-    private handleSnapshot;
-    /**
-     * Handle a patch message
-     */
-    private handlePatch;
-    /**
-     * Handle a result message
-     */
-    private handleResult;
-    /**
-     * Handle an error message
-     */
-    private handleError;
-    /**
-     * Resubscribe to all subscriptions after reconnect via HTTP
-     */
-    private resubscribeAll;
-    /**
-     * Notify subscription listeners of state changes
-     */
-    private notifySubscriptionListeners;
-    /**
-     * Notify connection state listeners
-     */
-    private notifyStateListeners;
-    /**
-     * Add a listener for subscription state changes
-     * Used internally by React hooks
-     */
-    addSubscriptionListener(id: string, listener: () => void): () => void;
-    /**
-     * Get subscription state
-     * Used internally by React hooks
-     */
-    getSubscriptionState<TData>(id: string): SubscriptionState<TData> | undefined;
-    /**
-     * Find subscription by path
-     */
-    private findSubscriptionByPath;
-    /**
-     * Apply an optimistic update to a subscription's data.
-     * Stores the original data for rollback (on mutation error) or as base for
-     * incoming server patches. Safe to call after external API calls — the next
-     * server snapshot/patch will reconcile automatically.
-     */
-    applyOptimisticUpdate(subscriptionId: string, updater: (data: unknown) => unknown): void;
-    /**
-     * Rollback an optimistic update
-     */
-    private rollbackOptimisticUpdate;
-    /**
-     * Clear optimistic state (called when real data arrives)
-     */
-    private clearOptimisticUpdate;
-}
-/**
- * Create a type-safe reactive client
- */
-declare function createReactiveClient<TRouter>(config: ReactiveClientConfig): TypedReactiveClient<TRouter>;
-/**
- * Type-safe client proxy type
- */
-type TypedReactiveClient<TRouter> = {
-    [K in keyof TRouter]: TRouter[K] extends {
-        query: unknown;
-    } ? {
-        useSubscription: <TData = unknown>(input?: unknown, options?: Omit<SubscriptionOptions<unknown>, 'input'>) => Subscription<TData>;
-    } : TRouter[K] extends {
-        mutation: unknown;
-    } ? {
-        mutate: <TInput, TOutput>(input: TInput) => Promise<TOutput>;
-    } : TypedReactiveClient<TRouter[K]>;
-} & {
-    _client: ReactiveClient;
-    connect: () => Promise<void>;
-    disconnect: () => void;
-};
-
-/**
- * Provider component for the reactive client
- *
- * If no config.url or client is provided, WebSocket features are disabled
- * and children are rendered without the reactive context.
- */
-declare function ReactiveClientProvider({ children, config, client: externalClient, }: {
-    children: ReactNode;
-    config?: ReactiveClientConfig;
-    client?: ReactiveClient;
-}): react_jsx_runtime.JSX.Element;
-/**
- * Hook to get the reactive client
- * Returns null if WebSocket is not configured
- */
-declare function useReactiveClient(): ReactiveClient | null;
-/**
- * Hook to get the reactive client, throwing if not available
- */
-declare function useReactiveClientOrThrow(): ReactiveClient;
-/**
- * Hook to get the connection state
- * Returns 'disabled' if WebSocket is not configured
- */
-declare function useConnectionState(): ConnectionState | 'disabled';
-/**
- * Hook for reactive subscriptions
- * Returns disabled state if WebSocket is not configured
- */
-declare function useSubscription<TData>(path: string, options?: SubscriptionOptions<unknown>): {
-    data: TData | undefined;
-    loading: boolean;
-    error: Error | undefined;
-    disabled: boolean;
-    refetch: () => Promise<void>;
-    setData: (updater: (data: TData) => TData) => void;
-};
-/**
- * Hook for mutations with automatic optimistic updates
- *
- * Auto-detection:
- * - `invalidates`: Auto-detected from path (e.g., 'todos.toggle' -> 'todos.list')
- * - `optimisticUpdate`: Auto-detected from path ('*.delete' -> 'remove', others -> 'merge')
- *
- * You can override these with explicit options.
- */
-declare function useMutation<TInput, TOutput>(path: string, options?: MutationOptions<TInput, TOutput>): {
-    mutate: (input: TInput) => Promise<TOutput>;
-    data: TOutput | undefined;
-    loading: boolean;
-    error: Error | undefined;
-    disabled: boolean;
-    reset: () => void;
-};
-/**
- * Type helper for extracting procedure input type from ProcedureDefinition
- * Uses Zod's internal _output property to extract the parsed type
- * (Zod schemas have _input/_output as actual properties for type inference)
- */
-type ProcedureInput<T> = T extends {
-    inputSchema?: {
-        _output: infer I;
-    };
-} ? I : undefined;
-/**
- * Type helper for extracting procedure output type from ProcedureDefinition
- * Extracts from resolver return type using any[] for flexible argument matching
- */
-type ProcedureOutput<T> = T extends {
-    resolver: (...args: any[]) => infer TReturn;
-} ? Awaited<TReturn> : unknown;
-/**
- * Typed client hooks for a router procedure
- * Provides both useQuery and useMutation - use whichever matches your procedure type
- */
-type TypedProcedureHooks<TInput, TOutput> = {
-    useQuery: (input: TInput, options?: Omit<SubscriptionOptions<TInput>, 'input'>) => {
-        data: TOutput | undefined;
-        loading: boolean;
-        error: Error | undefined;
-        disabled: boolean;
-        refetch: () => Promise<void>;
-        setData: (updater: (data: TOutput) => TOutput) => void;
-    };
-    useMutation: (options?: MutationOptions<TInput, TOutput>) => {
-        mutate: (input: TInput) => Promise<TOutput>;
-        data: TOutput | undefined;
-        loading: boolean;
-        error: Error | undefined;
-        disabled: boolean;
-        reset: () => void;
-    };
-};
-/**
- * Extract router definition from Router class or use T directly
- */
-type ExtractRouterDefinition<T> = T extends {
-    definition: infer TDef;
-} ? TDef : T;
-/**
- * Recursive type for typed client proxy
- * Checks for 'resolver' property to identify procedures (all procedures have it)
- */
-type TypedClientProxyRecursive<T> = T extends {
-    resolver: unknown;
-} ? TypedProcedureHooks<ProcedureInput<T>, ProcedureOutput<T>> : {
-    [K in keyof T]: TypedClientProxyRecursive<T[K]>;
-};
-/**
- * Client utilities available at the root level
- */
-interface ClientUtilities {
-    /**
-     * Set custom headers to be sent with HTTP requests.
-     * Useful for auth context (e.g., user tokens, session info).
-     */
-    setHeaders: (headers: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>)) => void;
-}
-/**
- * Typed client proxy combining router procedures and client utilities
- */
-type TypedClientProxy<T> = TypedClientProxyRecursive<ExtractRouterDefinition<T>> & ClientUtilities;
-/**
- * Create a typed client proxy for use in React components.
- *
- * @example
- * ```tsx
- * const client = useClient<AppRouter>();
- *
- * // Queries (subscriptions)
- * const { data, loading } = client.todos.list.useQuery({});
- *
- * // Mutations
- * const { mutate, loading } = client.todos.toggle.useMutation();
- * await mutate({ id: '123' });
- *
- * // Set custom headers for HTTP requests (e.g., for auth context)
- * client.setHeaders({ 'Authorization': 'Bearer token' });
- * ```
- */
-declare function useClient<TRouter>(): TypedClientProxy<TRouter>;
-/**
- * @deprecated Use useClient<TRouter>() instead for typed proxy access
- */
-declare function createReactiveHooks(): {
-    useSubscription: <TPath extends string, TData = unknown>(path: TPath, options?: SubscriptionOptions<unknown>) => {
-        data: TData | undefined;
-        loading: boolean;
-        error: Error | undefined;
-        disabled: boolean;
-        refetch: () => Promise<void>;
-        setData: (updater: (data: TData) => TData) => void;
-    };
-    useMutation: <TPath extends string, TInput = unknown, TOutput = unknown>(path: TPath, options?: MutationOptions<TInput, TOutput>) => {
-        mutate: (input: TInput) => Promise<TOutput>;
-        data: TOutput | undefined;
-        loading: boolean;
-        error: Error | undefined;
-        disabled: boolean;
-        reset: () => void;
-    };
-    useConnectionState: typeof useConnectionState;
-    useReactiveClient: typeof useReactiveClient;
-};
-/**
- * @deprecated Use useClient<TRouter>() instead for typed proxy access
- */
-declare function createProcedureHooks<TInput, TOutput>(path: string): {
-    useSubscription: (input?: TInput, options?: Omit<SubscriptionOptions<TInput>, "input">) => {
-        data: TOutput | undefined;
-        loading: boolean;
-        error: Error | undefined;
-        disabled: boolean;
-        refetch: () => Promise<void>;
-        setData: (updater: (data: TOutput) => TOutput) => void;
-    };
-    useMutation: (options?: MutationOptions<TInput, TOutput>) => {
-        mutate: (input: TInput) => Promise<TOutput>;
-        data: TOutput | undefined;
-        loading: boolean;
-        error: Error | undefined;
-        disabled: boolean;
-        reset: () => void;
-    };
-};
-
-export { type ConnectionState as C, type ErrorMessage as E, type InferInput as I, type JsonPatch as J, type MutationOptions as M, type PatchMessage as P, type ReactiveClientConfig as R, type ServerMessage as S, type TypedReactiveClient as T, type UnsubscribeMessage as U, type ClientMessage as a, ReactiveClient as b, createReactiveClient as c, type CallMessage as d, type InferOutput as e, type ResultMessage as f, type SnapshotMessage as g, type SubscribeMessage as h, type Subscription as i, type SubscriptionOptions as j, createProcedureHooks as k, createReactiveHooks as l, ReactiveClientProvider as m, useConnectionState as n, useMutation as o, useReactiveClient as p, useReactiveClientOrThrow as q, useSubscription as r, useClient as u };