dynamodb-reactive 0.1.0 → 0.1.1

package/dist/react-BMZQ8Mth.d.ts

@@ -0,0 +1,371 @@
+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;
+}
+type ClientMessage = SubscribeMessage | UnsubscribeMessage | CallMessage;
+/**
+ * Messages sent from server to client
+ */
+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;
+}
+type ServerMessage = SnapshotMessage | PatchMessage | ResultMessage | ErrorMessage;
+/**
+ * Client configuration
+ */
+interface ReactiveClientConfig {
+    /**
+     * WebSocket URL to connect to
+     */
+    url: string;
+    /**
+     * Authentication token or getter function
+     */
+    auth?: string | (() => string | Promise<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> {
+    /**
+     * 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;
+
+/**
+ * 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 subscriptions;
+    private pendingCalls;
+    private connectionState;
+    private stateListeners;
+    constructor(config: ReactiveClientConfig);
+    /**
+     * Connect to the server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): void;
+    /**
+     * Get current connection state
+     */
+    getConnectionState(): ConnectionState;
+    /**
+     * Subscribe to connection state changes
+     */
+    onConnectionStateChange(listener: (state: ConnectionState) => void): () => void;
+    /**
+     * Subscribe to a procedure
+     */
+    subscribe<TData>(path: string, options?: SubscriptionOptions<unknown>): Subscription<TData>;
+    /**
+     * Call a mutation procedure
+     */
+    call<TInput, TOutput>(path: string, input: TInput): Promise<TOutput>;
+    /**
+     * Unsubscribe from a subscription
+     */
+    private unsubscribe;
+    /**
+     * Refetch a subscription
+     */
+    private refetch;
+    /**
+     * Handle incoming server messages
+     */
+    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
+     */
+    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;
+}
+/**
+ * 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: any;
+    } ? {
+        useSubscription: <TData = unknown>(input?: unknown, options?: Omit<SubscriptionOptions<unknown>, 'input'>) => Subscription<TData>;
+    } : TRouter[K] extends {
+        mutation: any;
+    } ? {
+        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>;
+};
+/**
+ * Hook for mutations
+ * Throws if called when WebSocket is not configured
+ */
+declare function useMutation<TInput, TOutput>(path: string): {
+    mutate: (input: TInput) => Promise<TOutput>;
+    data: TOutput | undefined;
+    loading: boolean;
+    error: Error | undefined;
+    disabled: boolean;
+    reset: () => void;
+};
+/**
+ * Create typed React hooks from a router type
+ */
+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>;
+    };
+    useMutation: <TPath extends string, TInput = unknown, TOutput = unknown>(path: TPath) => {
+        mutate: (input: TInput) => Promise<TOutput>;
+        data: TOutput | undefined;
+        loading: boolean;
+        error: Error | undefined;
+        disabled: boolean;
+        reset: () => void;
+    };
+    useConnectionState: typeof useConnectionState;
+    useReactiveClient: typeof useReactiveClient;
+};
+/**
+ * Type-safe hook creator for a specific procedure path
+ */
+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>;
+    };
+    useMutation: () => {
+        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 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, useMutation as n, useReactiveClient as o, useReactiveClientOrThrow as p, useSubscription as q, useConnectionState as u };

package/dist/react.d.ts

@@ -1,2 +1,3 @@
-export * from '@dynamodb-reactive/client/react';
-//# sourceMappingURL=react.d.ts.map
+export { m as ReactiveClientProvider, k as createProcedureHooks, l as createReactiveHooks, u as useConnectionState, n as useMutation, o as useReactiveClient, p as useReactiveClientOrThrow, q as useSubscription } from './react-BMZQ8Mth.js';
+import 'react/jsx-runtime';
+import 'react';

package/dist/react.js

@@ -1,18 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("@dynamodb-reactive/client/react"), exports);
+export { ReactiveClientProvider, createProcedureHooks, createReactiveHooks, useConnectionState, useMutation, useReactiveClient, useReactiveClientOrThrow, useSubscription } from './chunk-KRZQWA2W.js';
+//# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -1 +1 @@
-{"version":3,"file":"react.js","sourceRoot":"","sources":["../src/react.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kEAAgD"}
+{"version":3,"sources":[],"names":[],"mappings":"","file":"react.js"}