dynamodb-reactive 0.1.21 → 0.2.1

package/dist/client-r_tnzwqi.d.ts

@@ -0,0 +1,224 @@
+/**
+ * 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;
+    /** Maximum time to wait for a usable connection. @default 10000 */
+    connectionTimeout?: number;
+    /** Maximum time for the init/connected/pong handshake. @default 10000 */
+    handshakeTimeout?: number;
+    /**
+     * Callback when connected
+     */
+    onConnect?: () => void;
+    /**
+     * Callback when disconnected
+     */
+    onDisconnect?: () => void;
+    /**
+     * Callback for errors
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Subscription options
+ */
+interface SubscriptionOptions<TInput = unknown, TData = unknown> {
+    /**
+     * Input for the subscription
+     */
+    input?: TInput;
+    /**
+     * Callback when data is received
+     */
+    onData?: (data: TData) => void;
+    /**
+     * Callback when an error occurs
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Active subscription
+ */
+interface Subscription<TData> {
+    /**
+     * Subscription ID (used for registering listeners)
+     */
+    id: string;
+    /** Stable canonical `(path,input)` key. */
+    key: string;
+    /**
+     * Current data
+     */
+    data: TData | undefined;
+    /**
+     * Whether the subscription is loading
+     */
+    loading: boolean;
+    /** Whether displayed data is waiting for authoritative reconciliation. */
+    stale: 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';
+/**
+ * Mutation options for optimistic updates
+ */
+interface MutationOptions<TInput = unknown, TOutput = unknown> {
+    /**
+     * Subscription path to optimistically update (e.g., 'todos.list')
+     * No subscription data is changed when no target is provided.
+     */
+    invalidates?: string | QueryTarget;
+    /** Canonical query key for targeting one exact active query. */
+    queryKey?: 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);
+}
+interface QueryTarget {
+    path: string;
+    input?: unknown;
+}
+
+/** Reactive client for shared, versioned subscriptions. */
+declare class ReactiveClient {
+    private wsManager;
+    private httpUrl;
+    private authGetter?;
+    private headersGetter?;
+    private subscriptionsById;
+    private subscriptionsByKey;
+    private connectionState;
+    private stateListeners;
+    constructor(config: ReactiveClientConfig);
+    /** Apply live configuration without replacing subscription caches or the socket. */
+    configure(config: ReactiveClientConfig): void;
+    connect(): Promise<void>;
+    disconnect(): void;
+    forceReconnect(): void;
+    getConnectionState(): ConnectionState;
+    onConnectionStateChange(listener: (state: ConnectionState) => void): () => void;
+    subscribe<TData, TInput = unknown>(path: string, options?: SubscriptionOptions<TInput, TData>): Subscription<TData>;
+    call<TInput, TOutput>(path: string, input: TInput, options?: MutationOptions<TInput, TOutput>): Promise<TOutput>;
+    addSubscriptionListener(id: string, listener: () => void): () => void;
+    getSubscriptionRevision(id: string): number;
+    applyOptimisticUpdate(subscriptionId: string, updater: (data: unknown) => unknown): void;
+    private setAuth;
+    private setInitialHeaders;
+    private toAuthGetter;
+    private toHeadersGetter;
+    private registerActiveSubscriptions;
+    private ensureRegistered;
+    private releaseSubscription;
+    private sendUnsubscribe;
+    private refetch;
+    private handleMessage;
+    private handleSnapshot;
+    private handlePatch;
+    private drainPatchBuffer;
+    private discardStalePatches;
+    private requestResync;
+    private createMutationLayers;
+    private findMutationTargets;
+    private createOptimisticUpdater;
+    private settleMutationLayers;
+    private removeMutationLayers;
+    private recomputeData;
+    private hasSettledLayers;
+    private buildHeaders;
+    private markSubscriptionsStale;
+    private notifySubscription;
+    private notifyStateListeners;
+}
+type ProcedureInput<T> = T extends {
+    inputSchema?: {
+        _output: infer TInput;
+    };
+} ? TInput : undefined;
+type ProcedureOutput<T> = T extends {
+    resolver: (...args: any[]) => infer TReturn;
+} ? Awaited<TReturn> : unknown;
+type ExtractRouterDefinition<T> = T extends {
+    definition: infer TDefinition;
+} ? TDefinition : T;
+type QueryProcedure<T> = [ProcedureInput<T>] extends [undefined] ? {
+    useSubscription: (input?: undefined, options?: Omit<SubscriptionOptions<undefined, ProcedureOutput<T>>, 'input'>) => Subscription<ProcedureOutput<T>>;
+} : {
+    useSubscription: (input: ProcedureInput<T>, options?: Omit<SubscriptionOptions<ProcedureInput<T>, ProcedureOutput<T>>, 'input'>) => Subscription<ProcedureOutput<T>>;
+};
+type MutationProcedure<T> = [ProcedureInput<T>] extends [undefined] ? {
+    mutate: (input?: undefined, options?: MutationOptions<undefined, ProcedureOutput<T>>) => Promise<ProcedureOutput<T>>;
+} : {
+    mutate: (input: ProcedureInput<T>, options?: MutationOptions<ProcedureInput<T>, ProcedureOutput<T>>) => Promise<ProcedureOutput<T>>;
+};
+type TypedReactiveClientTree<T> = T extends {
+    type: 'query';
+} ? QueryProcedure<T> : T extends {
+    type: 'mutation';
+} ? MutationProcedure<T> : {
+    [K in keyof T]: TypedReactiveClientTree<T[K]>;
+};
+type TypedReactiveClient<TRouter> = TypedReactiveClientTree<ExtractRouterDefinition<TRouter>> & {
+    connect: () => Promise<void>;
+    disconnect: () => void;
+};
+declare function createReactiveClient<TRouter>(config: ReactiveClientConfig): TypedReactiveClient<TRouter>;
+
+export { ReactiveClient as R, createReactiveClient as c };
+export type { ConnectionState as C, MutationOptions as M, QueryTarget as Q, Subscription as S, TypedReactiveClient as T, ReactiveClientConfig as a, SubscriptionOptions as b };