dynamodb-reactive 0.1.0 → 0.1.1

package/dist/chunk-KRZQWA2W.js

@@ -0,0 +1,657 @@
+import { applyPatch } from 'fast-json-patch';
+import { createContext, useState, useEffect, useContext, useSyncExternalStore, useRef } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// ../client/src/patcher.ts
+function applyPatches(document, patches) {
+  if (patches.length === 0) {
+    return document;
+  }
+  const operations = patches.map((patch) => {
+    const op = {
+      op: patch.op,
+      path: patch.path
+    };
+    if ("value" in patch && patch.value !== void 0) {
+      op.value = patch.value;
+    }
+    if ("from" in patch && patch.from !== void 0) {
+      op.from = patch.from;
+    }
+    return op;
+  });
+  try {
+    const result = applyPatch(
+      structuredClone(document),
+      operations,
+      true,
+      // Validate operations
+      false
+      // Don't mutate the original
+    );
+    return result.newDocument;
+  } catch (error) {
+    console.error("Failed to apply patches:", error);
+    throw error;
+  }
+}
+
+// ../client/src/websocket.ts
+var WebSocketManager = class {
+  config;
+  ws = null;
+  state = "disconnected";
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  messageQueue = [];
+  messageHandlers = /* @__PURE__ */ new Set();
+  stateHandlers = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = {
+      autoReconnect: true,
+      reconnectDelay: 1e3,
+      maxReconnectAttempts: 10,
+      ...config
+    };
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Connect to the WebSocket server
+   */
+  async connect() {
+    if (this.state === "connected" || this.state === "connecting") {
+      return;
+    }
+    this.setState("connecting");
+    try {
+      const url = await this.buildUrl();
+      this.ws = new WebSocket(url);
+      this.ws.onopen = () => {
+        this.setState("connected");
+        this.reconnectAttempts = 0;
+        this.flushMessageQueue();
+        this.config.onConnect?.();
+      };
+      this.ws.onclose = (event) => {
+        this.ws = null;
+        this.setState("disconnected");
+        this.config.onDisconnect?.();
+        if (this.config.autoReconnect && !event.wasClean) {
+          this.scheduleReconnect();
+        }
+      };
+      this.ws.onerror = () => {
+        const error = new Error("WebSocket error");
+        this.config.onError?.(error);
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const message = JSON.parse(event.data);
+          this.handleMessage(message);
+        } catch (error) {
+          console.error("Failed to parse WebSocket message:", error);
+        }
+      };
+    } catch (error) {
+      this.setState("disconnected");
+      this.config.onError?.(
+        error instanceof Error ? error : new Error(String(error))
+      );
+      if (this.config.autoReconnect) {
+        this.scheduleReconnect();
+      }
+    }
+  }
+  /**
+   * Disconnect from the WebSocket server
+   */
+  disconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close(1e3, "Client disconnect");
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (this.state === "connected" && this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+    } else {
+      this.messageQueue.push(message);
+    }
+  }
+  /**
+   * Subscribe to incoming messages
+   */
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  /**
+   * Subscribe to connection state changes
+   */
+  onStateChange(handler) {
+    this.stateHandlers.add(handler);
+    return () => this.stateHandlers.delete(handler);
+  }
+  async buildUrl() {
+    let url = this.config.url;
+    if (this.config.auth) {
+      const token = typeof this.config.auth === "function" ? await this.config.auth() : this.config.auth;
+      const separator = url.includes("?") ? "&" : "?";
+      url = `${url}${separator}token=${encodeURIComponent(token)}`;
+    }
+    return url;
+  }
+  setState(state) {
+    this.state = state;
+    for (const handler of this.stateHandlers) {
+      handler(state);
+    }
+  }
+  handleMessage(message) {
+    for (const handler of this.messageHandlers) {
+      handler(message);
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      console.error("Max reconnection attempts reached");
+      return;
+    }
+    this.setState("reconnecting");
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
+      3e4
+      // Max 30 seconds
+    ) * (0.5 + Math.random() * 0.5);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.connect();
+    }, delay);
+  }
+  flushMessageQueue() {
+    const queue = this.messageQueue;
+    this.messageQueue = [];
+    for (const message of queue) {
+      this.send(message);
+    }
+  }
+};
+
+// ../client/src/client.ts
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+var ReactiveClient = class {
+  wsManager;
+  subscriptions = /* @__PURE__ */ new Map();
+  pendingCalls = /* @__PURE__ */ new Map();
+  connectionState = "disconnected";
+  stateListeners = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.wsManager = new WebSocketManager(config);
+    this.wsManager.onMessage((message) => this.handleMessage(message));
+    this.wsManager.onStateChange((state) => {
+      this.connectionState = state;
+      this.notifyStateListeners();
+      if (state === "connected") {
+        this.resubscribeAll();
+      }
+    });
+  }
+  /**
+   * Connect to the server
+   */
+  async connect() {
+    await this.wsManager.connect();
+  }
+  /**
+   * Disconnect from the server
+   */
+  disconnect() {
+    this.wsManager.disconnect();
+  }
+  /**
+   * Get current connection state
+   */
+  getConnectionState() {
+    return this.connectionState;
+  }
+  /**
+   * Subscribe to connection state changes
+   */
+  onConnectionStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => this.stateListeners.delete(listener);
+  }
+  /**
+   * Subscribe to a procedure
+   */
+  subscribe(path, options = {}) {
+    const id = generateId();
+    const state = {
+      id,
+      path,
+      input: options.input,
+      data: void 0,
+      loading: true,
+      error: void 0,
+      listeners: /* @__PURE__ */ new Set(),
+      options
+    };
+    this.subscriptions.set(id, state);
+    this.wsManager.send({
+      type: "subscribe",
+      subscriptionId: id,
+      path,
+      input: options.input
+    });
+    const subscription = {
+      get data() {
+        return state.data;
+      },
+      get loading() {
+        return state.loading;
+      },
+      get error() {
+        return state.error;
+      },
+      unsubscribe: () => this.unsubscribe(id),
+      refetch: () => this.refetch(id)
+    };
+    return subscription;
+  }
+  /**
+   * Call a mutation procedure
+   */
+  async call(path, input) {
+    const callId = generateId();
+    return new Promise((resolve, reject) => {
+      this.pendingCalls.set(callId, {
+        resolve,
+        reject
+      });
+      this.wsManager.send({
+        type: "call",
+        callId,
+        path,
+        input
+      });
+      setTimeout(() => {
+        if (this.pendingCalls.has(callId)) {
+          this.pendingCalls.delete(callId);
+          reject(new Error("Call timeout"));
+        }
+      }, 3e4);
+    });
+  }
+  /**
+   * Unsubscribe from a subscription
+   */
+  unsubscribe(id) {
+    const state = this.subscriptions.get(id);
+    if (!state) return;
+    this.subscriptions.delete(id);
+    this.wsManager.send({
+      type: "unsubscribe",
+      subscriptionId: id
+    });
+  }
+  /**
+   * Refetch a subscription
+   */
+  async refetch(id) {
+    const state = this.subscriptions.get(id);
+    if (!state) return;
+    state.loading = true;
+    this.notifySubscriptionListeners(id);
+    this.wsManager.send({
+      type: "subscribe",
+      subscriptionId: id,
+      path: state.path,
+      input: state.input
+    });
+  }
+  /**
+   * Handle incoming server messages
+   */
+  handleMessage(message) {
+    switch (message.type) {
+      case "snapshot":
+        this.handleSnapshot(message.subscriptionId, message.data);
+        break;
+      case "patch":
+        this.handlePatch(message.subscriptionId, message.patches);
+        break;
+      case "result":
+        this.handleResult(message.callId, message.data);
+        break;
+      case "error":
+        this.handleError(message);
+        break;
+    }
+  }
+  /**
+   * Handle a snapshot message
+   */
+  handleSnapshot(subscriptionId, data) {
+    const state = this.subscriptions.get(subscriptionId);
+    if (!state) return;
+    state.data = data;
+    state.loading = false;
+    state.error = void 0;
+    this.notifySubscriptionListeners(subscriptionId);
+    state.options.onData?.(data);
+  }
+  /**
+   * Handle a patch message
+   */
+  handlePatch(subscriptionId, patches) {
+    const state = this.subscriptions.get(subscriptionId);
+    if (!state || state.data === void 0) return;
+    try {
+      state.data = applyPatches(state.data, patches);
+      this.notifySubscriptionListeners(subscriptionId);
+      state.options.onData?.(state.data);
+    } catch (error) {
+      state.error = error instanceof Error ? error : new Error(String(error));
+      this.notifySubscriptionListeners(subscriptionId);
+      state.options.onError?.(state.error);
+    }
+  }
+  /**
+   * Handle a result message
+   */
+  handleResult(callId, data) {
+    const pending = this.pendingCalls.get(callId);
+    if (!pending) return;
+    this.pendingCalls.delete(callId);
+    pending.resolve(data);
+  }
+  /**
+   * Handle an error message
+   */
+  handleError(message) {
+    const error = new Error(message.message);
+    if (message.subscriptionId) {
+      const state = this.subscriptions.get(message.subscriptionId);
+      if (state) {
+        state.error = error;
+        state.loading = false;
+        this.notifySubscriptionListeners(message.subscriptionId);
+        state.options.onError?.(error);
+      }
+    }
+    if (message.callId) {
+      const pending = this.pendingCalls.get(message.callId);
+      if (pending) {
+        this.pendingCalls.delete(message.callId);
+        pending.reject(error);
+      }
+    }
+  }
+  /**
+   * Resubscribe to all subscriptions after reconnect
+   */
+  resubscribeAll() {
+    for (const [id, state] of this.subscriptions) {
+      if (state.options.resubscribeOnReconnect !== false) {
+        state.loading = true;
+        this.notifySubscriptionListeners(id);
+        this.wsManager.send({
+          type: "subscribe",
+          subscriptionId: id,
+          path: state.path,
+          input: state.input
+        });
+      }
+    }
+  }
+  /**
+   * Notify subscription listeners of state changes
+   */
+  notifySubscriptionListeners(id) {
+    const state = this.subscriptions.get(id);
+    if (!state) return;
+    for (const listener of state.listeners) {
+      listener();
+    }
+  }
+  /**
+   * Notify connection state listeners
+   */
+  notifyStateListeners() {
+    for (const listener of this.stateListeners) {
+      listener(this.connectionState);
+    }
+  }
+  /**
+   * Add a listener for subscription state changes
+   * Used internally by React hooks
+   */
+  addSubscriptionListener(id, listener) {
+    const state = this.subscriptions.get(id);
+    if (!state) return () => {
+    };
+    state.listeners.add(listener);
+    return () => state.listeners.delete(listener);
+  }
+  /**
+   * Get subscription state
+   * Used internally by React hooks
+   */
+  getSubscriptionState(id) {
+    return this.subscriptions.get(id);
+  }
+};
+function createReactiveClient(config) {
+  const client = new ReactiveClient(config);
+  return createTypedProxy(client, []);
+}
+function createTypedProxy(client, path) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        if (prop === "_client") return client;
+        if (prop === "connect") return () => client.connect();
+        if (prop === "disconnect") return () => client.disconnect();
+        if (typeof prop !== "string") return void 0;
+        const newPath = [...path, prop];
+        if (prop === "useSubscription") {
+          return (input, options) => {
+            const parentPath = path.join(".");
+            return client.subscribe(parentPath, { ...options, input });
+          };
+        }
+        if (prop === "mutate") {
+          return async (input) => {
+            const parentPath = path.join(".");
+            return client.call(parentPath, input);
+          };
+        }
+        return createTypedProxy(client, newPath);
+      }
+    }
+  );
+}
+var ReactiveClientContext = createContext(null);
+function ReactiveClientProvider({
+  children,
+  config,
+  client: externalClient
+}) {
+  const url = config?.url;
+  const hasUrl = Boolean(url);
+  const [client, setClient] = useState(
+    externalClient ?? null
+  );
+  useEffect(() => {
+    if (externalClient || !url) return;
+    if (!client) {
+      const newClient = new ReactiveClient({ ...config, url });
+      setClient(newClient);
+    }
+  }, [url, externalClient]);
+  useEffect(() => {
+    if (!client) return;
+    void client.connect();
+    return () => {
+      client.disconnect();
+    };
+  }, [client]);
+  useEffect(() => {
+    if (!hasUrl && process.env.NODE_ENV === "development") {
+      console.warn(
+        "[dynamodb-reactive] WebSocket URL not configured, real-time features disabled"
+      );
+    }
+  }, [hasUrl]);
+  return /* @__PURE__ */ jsx(ReactiveClientContext.Provider, { value: client, children });
+}
+function useReactiveClient() {
+  return useContext(ReactiveClientContext);
+}
+function useReactiveClientOrThrow() {
+  const client = useContext(ReactiveClientContext);
+  if (!client) {
+    throw new Error(
+      "useReactiveClientOrThrow must be used within a ReactiveClientProvider with a configured URL"
+    );
+  }
+  return client;
+}
+function useConnectionState() {
+  const client = useReactiveClient();
+  return useSyncExternalStore(
+    (callback) => {
+      if (!client) return () => {
+      };
+      return client.onConnectionStateChange(callback);
+    },
+    () => client ? client.getConnectionState() : "disabled",
+    () => "disabled"
+  );
+}
+function useSubscription(path, options = {}) {
+  const client = useReactiveClient();
+  const subscriptionRef = useRef(null);
+  const [state, setState] = useState({
+    data: void 0,
+    loading: !client ? false : true,
+    error: void 0
+  });
+  const inputKey = JSON.stringify(options.input);
+  const onDataRef = useRef(options.onData);
+  const onErrorRef = useRef(options.onError);
+  onDataRef.current = options.onData;
+  onErrorRef.current = options.onError;
+  useEffect(() => {
+    if (!client) return;
+    const input = inputKey ? JSON.parse(inputKey) : void 0;
+    const subscription = client.subscribe(path, {
+      input,
+      onData: (data) => {
+        setState((prev) => ({
+          ...prev,
+          data,
+          loading: false,
+          error: void 0
+        }));
+        onDataRef.current?.(data);
+      },
+      onError: (error) => {
+        setState((prev) => ({
+          ...prev,
+          error,
+          loading: false
+        }));
+        onErrorRef.current?.(error);
+      }
+    });
+    subscriptionRef.current = subscription;
+    setState({
+      data: subscription.data,
+      loading: subscription.loading,
+      error: subscription.error
+    });
+    return () => {
+      subscription.unsubscribe();
+      subscriptionRef.current = null;
+    };
+  }, [client, path, inputKey]);
+  const refetch = async () => {
+    if (subscriptionRef.current) {
+      setState((prev) => ({ ...prev, loading: true }));
+      await subscriptionRef.current.refetch();
+    }
+  };
+  return {
+    ...state,
+    disabled: !client,
+    refetch
+  };
+}
+function useMutation(path) {
+  const client = useReactiveClient();
+  const [state, setState] = useState({
+    data: void 0,
+    loading: false,
+    error: void 0
+  });
+  const mutate = async (input) => {
+    if (!client) {
+      throw new Error("WebSocket not configured - mutations are disabled");
+    }
+    setState((prev) => ({ ...prev, loading: true, error: void 0 }));
+    try {
+      const result = await client.call(path, input);
+      setState({ data: result, loading: false, error: void 0 });
+      return result;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      setState((prev) => ({ ...prev, loading: false, error: err }));
+      throw err;
+    }
+  };
+  const reset = () => {
+    setState({ data: void 0, loading: false, error: void 0 });
+  };
+  return {
+    mutate,
+    ...state,
+    disabled: !client,
+    reset
+  };
+}
+function createReactiveHooks() {
+  return {
+    useSubscription: (path, options) => useSubscription(path, options),
+    useMutation: (path) => useMutation(path),
+    useConnectionState,
+    useReactiveClient
+  };
+}
+function createProcedureHooks(path) {
+  return {
+    useSubscription: (input, options) => useSubscription(path, { ...options, input }),
+    useMutation: () => useMutation(path)
+  };
+}
+
+export { ReactiveClient, ReactiveClientProvider, WebSocketManager, applyPatches, createProcedureHooks, createReactiveClient, createReactiveHooks, useConnectionState, useMutation, useReactiveClient, useReactiveClientOrThrow, useSubscription };
+//# sourceMappingURL=chunk-KRZQWA2W.js.map
+//# sourceMappingURL=chunk-KRZQWA2W.js.map