@reifydb/react 0.9.1 → 0.9.3

package/dist/index.js

@@ -1,1010 +1,103 @@
 // src/index.ts
 export * from "@reifydb/core";
 export * from "@reifydb/client";
+export * from "@reifydb/store";
 
-// src/connection/connection.ts
-import { Client } from "@reifydb/client";
-var DEFAULT_CONFIG = {
-  url: "ws://127.0.0.1:8090",
-  options: { timeoutMs: 3e4 }
-};
-var DEFAULT_URL = "ws://127.0.0.1:8090";
-var Connection = class {
-  constructor(config = DEFAULT_CONFIG) {
-    this.state = {
-      client: null,
-      isConnected: false,
-      isConnecting: false,
-      connectionError: null,
-      listeners: /* @__PURE__ */ new Set()
-    };
-    this.connectPromise = null;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-  setConfig(config) {
-    this.config = config;
-  }
-  getConfig() {
-    return this.config;
-  }
-  async connect(url, options) {
-    if (this.state.isConnected) {
-      return;
-    }
-    if (this.connectPromise) {
-      return this.connectPromise;
-    }
-    const connectUrl = url || this.config.url || DEFAULT_CONFIG.url;
-    const connectOptions = { token: this.config.token, ...this.config.options, ...options };
-    this.updateState({
-      isConnecting: true,
-      connectionError: null
-    });
-    this.connectPromise = (async () => {
-      try {
-        const isHttp = connectUrl.startsWith("http://") || connectUrl.startsWith("https://");
-        const isJson = this.config.format === "json";
-        let client;
-        if (isHttp) {
-          client = isJson ? Client.connectJsonHttp(connectUrl, connectOptions) : Client.connectHttp(connectUrl, connectOptions);
-        } else {
-          client = isJson ? await Client.connectJsonWs(connectUrl, connectOptions) : await Client.connectWs(connectUrl, connectOptions);
-        }
-        this.updateState({
-          client,
-          isConnected: true,
-          isConnecting: false,
-          connectionError: null
-        });
-      } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : "Failed to connect to ReifyDB";
-        console.error("[Connection] Connection failed:", errorMessage, err);
-        this.updateState({
-          client: null,
-          isConnected: false,
-          isConnecting: false,
-          connectionError: errorMessage
-        });
-        throw err;
-      } finally {
-        this.connectPromise = null;
-      }
-    })();
-    return this.connectPromise;
-  }
-  async disconnect() {
-    this.connectPromise = null;
-    if (this.state.client) {
-      try {
-        if ("disconnect" in this.state.client) {
-          await this.state.client.disconnect();
-        }
-      } catch (err) {
-        console.error("Error disconnecting:", err);
-      }
-    }
-    this.updateState({
-      client: null,
-      isConnected: false,
-      isConnecting: false,
-      connectionError: null
-    });
-  }
-  async reconnect(url, options) {
-    await this.disconnect();
-    await this.connect(url, options);
-  }
-  getClient() {
-    return this.state.client;
-  }
-  isConnected() {
-    return this.state.isConnected;
-  }
-  isConnecting() {
-    return this.state.isConnecting;
-  }
-  getConnectionError() {
-    return this.state.connectionError;
+// src/provider.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var StoreContext = createContext(void 0);
+function StoreProvider({ store, children }) {
+  return /* @__PURE__ */ jsx(StoreContext.Provider, { value: store, children });
+}
+function useStore() {
+  const store = useContext(StoreContext);
+  if (store === void 0) {
+    throw new Error("useStore must be used inside a StoreProvider");
   }
-  getState() {
-    const { listeners, ...state } = this.state;
-    return state;
-  }
-  // Subscribe to state changes
-  subscribe(listener) {
-    this.state.listeners.add(listener);
-    return () => {
-      this.state.listeners.delete(listener);
-    };
-  }
-  updateState(updates) {
-    this.state = {
-      ...this.state,
-      ...updates
-    };
-    this.state.listeners.forEach((listener) => {
-      listener(this.state);
-    });
-  }
-};
-
-// src/connection/connection-pool.ts
-var defaultConnection = null;
-function getConnection(config) {
-  if (!defaultConnection) {
-    const mergedConfig = { ...DEFAULT_CONFIG, ...config };
-    defaultConnection = new Connection(mergedConfig);
-    defaultConnection.connect().catch((err) => {
-      console.error("[ConnectionPool] Eager connect failed:", err);
-    });
-  } else if (config) {
-    defaultConnection.setConfig({ ...DEFAULT_CONFIG, ...config });
-  }
-  return defaultConnection;
-}
-async function clearConnection() {
-  if (defaultConnection) {
-    await defaultConnection.disconnect();
-    defaultConnection = null;
-  }
-}
-
-// src/connection/connection-context.tsx
-import React, { createContext, useEffect, useRef } from "react";
-var ConnectionContext = createContext(null);
-function ConnectionProvider({ config, children }) {
-  const connection = getConnection(config);
-  const prevConfigRef = useRef(void 0);
-  const currentConfigStr = JSON.stringify(config);
-  useEffect(() => {
-    const configChanged = prevConfigRef.current !== void 0 && prevConfigRef.current !== currentConfigStr;
-    if (configChanged && connection.isConnected()) {
-      connection.reconnect().catch((err) => {
-        console.error("[ConnectionProvider] Failed to reconnect:", err);
-      });
-    } else if (!connection.isConnected() && !connection.isConnecting()) {
-      connection.connect().catch((err) => {
-        console.error("[ConnectionProvider] Failed to connect:", err);
-      });
-    }
-    prevConfigRef.current = currentConfigStr;
-  }, [currentConfigStr, connection]);
-  return /* @__PURE__ */ React.createElement(ConnectionContext.Provider, { value: connection }, children);
-}
-
-// src/hooks/use-connection.ts
-import { useContext, useEffect as useEffect2, useState } from "react";
-function useConnection(overrideConfig) {
-  const contextConnection = useContext(ConnectionContext);
-  const [connection] = useState(() => {
-    if (overrideConfig) {
-      return getConnection(overrideConfig);
-    }
-    if (contextConnection) {
-      return contextConnection;
-    }
-    return getConnection();
-  });
-  const [state, setState] = useState(() => connection.getState());
-  useEffect2(() => {
-    const currentState = connection.getState();
-    setState(currentState);
-    const unsubscribe = connection.subscribe((newState) => {
-      setState({
-        client: newState.client,
-        isConnected: newState.isConnected,
-        isConnecting: newState.isConnecting,
-        connectionError: newState.connectionError
-      });
-    });
-    return unsubscribe;
-  }, [connection]);
-  return {
-    ...state,
-    connect: () => connection.connect(),
-    disconnect: () => connection.disconnect(),
-    reconnect: () => connection.reconnect()
-  };
+  return store;
 }
 
-// src/hooks/use-query-executor.ts
-import { useState as useState2, useCallback, useRef as useRef2, useEffect as useEffect3 } from "react";
-function useQueryExecutor(options) {
-  const { client } = useConnection(options?.connectionConfig);
-  const [state, setState] = useState2({
-    isExecuting: false,
-    results: void 0,
-    error: void 0,
-    executionTime: void 0
-  });
-  const clientRef = useRef2(client);
-  clientRef.current = client;
-  const isMountedRef = useRef2(true);
-  useEffect3(() => {
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-  const executionIdRef = useRef2(0);
-  const pendingRef = useRef2(null);
-  const query = useCallback(
-    (rql, params, shapes) => {
-      const currentClient = clientRef.current;
-      if (!currentClient) {
-        pendingRef.current = { rql, params, shapes };
-        setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-        return Promise.resolve();
-      }
-      pendingRef.current = null;
-      const thisExecution = ++executionIdRef.current;
-      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-      const startTime = Date.now();
-      return (async () => {
-        try {
-          const frameResults = await currentClient.query(rql, params || null, shapes || []) || [];
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          const results = frameResults.map((frame) => {
-            if (Array.isArray(frame) && frame.length > 0) {
-              const firstRow = frame[0];
-              let columns = [];
-              const hasValueObjects = firstRow && typeof firstRow === "object" && Object.values(firstRow).some((v) => v && typeof v === "object" && "type" in v);
-              if (hasValueObjects) {
-                columns = Object.keys(firstRow).map((key) => {
-                  const value = firstRow[key];
-                  const dataType = value?.type || "Utf8";
-                  return {
-                    name: key,
-                    type: dataType,
-                    payload: []
-                  };
-                });
-              } else {
-                columns = Object.keys(firstRow).map((key) => ({
-                  name: key,
-                  type: "Utf8",
-                  payload: []
-                }));
-              }
-              return {
-                columns,
-                rows: frame,
-                executionTimeMs: executionTime
-              };
-            } else {
-              return {
-                columns: [],
-                rows: [],
-                executionTimeMs: executionTime
-              };
-            }
-          });
-          if (!isMountedRef.current) return;
-          setState({
-            isExecuting: false,
-            results,
-            error: void 0,
-            executionTime
-          });
-        } catch (err) {
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          let errorMessage = "Query execution failed";
-          if (err instanceof Error) {
-            errorMessage = err.message;
-          } else if (typeof err === "string") {
-            errorMessage = err;
-          } else if (err && typeof err === "object" && "message" in err) {
-            errorMessage = err.message;
-          }
-          console.error("Query execution failed:", errorMessage);
-          if (!isMountedRef.current) return;
-          setState((prev) => ({
-            ...prev,
-            isExecuting: false,
-            error: errorMessage,
-            executionTime
-          }));
-        }
-      })();
-    },
-    []
-  );
-  useEffect3(() => {
-    if (client && pendingRef.current) {
-      const { rql, params, shapes } = pendingRef.current;
-      query(rql, params, shapes);
-    }
-  }, [client, query]);
-  const cancelQuery = useCallback(() => {
-    executionIdRef.current++;
-    setState((prev) => ({
-      ...prev,
-      isExecuting: false,
-      error: "Query cancelled"
-    }));
-  }, []);
-  return {
-    isExecuting: state.isExecuting,
-    results: state.results,
-    error: state.error,
-    executionTime: state.executionTime,
-    query,
-    cancelQuery
-  };
-}
+// src/use-subscription.ts
+import { useEffect } from "react";
+import { entryKey } from "@reifydb/store";
 
-// src/hooks/use-query.ts
-import { useEffect as useEffect4, useMemo } from "react";
-function useQueryOne(rql, params, shape, options) {
-  const {
-    isExecuting,
-    results,
-    error,
-    query
-  } = useQueryExecutor(options);
-  useEffect4(() => {
-    const shapes = shape ? [shape] : void 0;
-    query(rql, params, shapes);
-  }, [rql, params, query]);
-  const result = useMemo(() => {
-    return results && results.length > 0 ? results[0] : void 0;
-  }, [results]);
-  return { isExecuting, result, error };
-}
-function useQueryMany(rql, params, shapes, options) {
-  const {
-    isExecuting,
-    results,
-    error,
-    query
-  } = useQueryExecutor(options);
-  useEffect4(() => {
-    query(rql, params, shapes);
-  }, [rql, params, query]);
-  return { isExecuting, results, error };
+// src/use-entry.ts
+import { useCallback, useSyncExternalStore } from "react";
+function useEntry(store, rql, params, shape) {
+  const subscribe = useCallback((listener) => store.subscribeState(listener), [store]);
+  return useSyncExternalStore(subscribe, () => store.getEntry(rql, params, shape));
 }
 
-// src/hooks/use-command-executor.ts
-import { useState as useState3, useCallback as useCallback2, useRef as useRef3, useEffect as useEffect5 } from "react";
-function useCommandExecutor(options) {
-  const { client } = useConnection(options?.connectionConfig);
-  const [state, setState] = useState3({
-    isExecuting: false,
-    results: void 0,
-    error: void 0,
-    executionTime: void 0
-  });
-  const clientRef = useRef3(client);
-  clientRef.current = client;
-  const isMountedRef = useRef3(false);
-  useEffect5(() => {
-    isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-  const executionIdRef = useRef3(0);
-  const pendingRef = useRef3(null);
-  const command = useCallback2(
-    (rql, params, shapes) => {
-      const currentClient = clientRef.current;
-      if (!currentClient) {
-        pendingRef.current = { rql, params, shapes };
-        setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-        return Promise.resolve();
-      }
-      pendingRef.current = null;
-      const thisExecution = ++executionIdRef.current;
-      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-      const startTime = Date.now();
-      return (async () => {
-        try {
-          const frameResults = await currentClient.command(rql, params || null, shapes || []) || [];
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          const results = frameResults.map((frame) => {
-            if (Array.isArray(frame) && frame.length > 0) {
-              const firstRow = frame[0];
-              let columns = [];
-              const hasValueObjects = firstRow && typeof firstRow === "object" && Object.values(firstRow).some((v) => v && typeof v === "object" && "type" in v);
-              if (hasValueObjects) {
-                columns = Object.keys(firstRow).map((key) => {
-                  const value = firstRow[key];
-                  const dataType = value?.type || "Utf8";
-                  return {
-                    name: key,
-                    type: dataType,
-                    payload: []
-                  };
-                });
-              } else {
-                columns = Object.keys(firstRow).map((key) => ({
-                  name: key,
-                  type: "Utf8",
-                  payload: []
-                }));
-              }
-              return {
-                columns,
-                rows: frame,
-                executionTimeMs: executionTime
-              };
-            } else {
-              return {
-                columns: [],
-                rows: [],
-                executionTimeMs: executionTime,
-                rowsAffected: typeof frame === "number" ? frame : void 0
-              };
-            }
-          });
-          if (!isMountedRef.current) return;
-          setState({
-            isExecuting: false,
-            results,
-            error: void 0,
-            executionTime
-          });
-        } catch (err) {
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          let errorMessage = "Command execution failed";
-          if (err instanceof Error) {
-            errorMessage = err.message;
-          } else if (typeof err === "string") {
-            errorMessage = err;
-          } else if (err && typeof err === "object" && "message" in err) {
-            errorMessage = err.message;
-          }
-          console.error("Command execution failed:", errorMessage);
-          if (!isMountedRef.current) return;
-          setState((prev) => ({
-            ...prev,
-            isExecuting: false,
-            error: errorMessage,
-            executionTime
-          }));
-        }
-      })();
-    },
-    []
-  );
-  useEffect5(() => {
-    if (client && pendingRef.current) {
-      const { rql, params, shapes } = pendingRef.current;
-      command(rql, params, shapes);
+// src/use-subscription.ts
+function useSubscription(rql, params, shape, options = {}) {
+  const store = useStore();
+  const { config, enabled = true } = options;
+  const key = entryKey(rql, params, shape);
+  useEffect(() => {
+    if (!enabled) {
+      return;
     }
-  }, [client, command]);
-  const cancelCommand = useCallback2(() => {
-    executionIdRef.current++;
-    setState((prev) => ({
-      ...prev,
-      isExecuting: false,
-      error: "Command cancelled"
-    }));
-  }, []);
-  return {
-    isExecuting: state.isExecuting,
-    results: state.results,
-    error: state.error,
-    executionTime: state.executionTime,
-    command,
-    cancelCommand
-  };
+    return store.subscribe(rql, params, shape, config);
+  }, [store, key, enabled]);
+  return useEntry(store, rql, params, shape);
 }
 
-// src/hooks/use-command.ts
-import { useEffect as useEffect6, useMemo as useMemo2 } from "react";
-function useCommandOne(rql, params, shape, options) {
-  const {
-    isExecuting,
-    results,
-    error,
-    command
-  } = useCommandExecutor(options);
-  useEffect6(() => {
-    const shapes = shape ? [shape] : void 0;
-    command(rql, params, shapes);
-  }, [rql, params, command]);
-  const result = useMemo2(() => {
-    return results && results.length > 0 ? results[0] : void 0;
-  }, [results]);
-  return { isExecuting, result, error };
-}
-function useCommandMany(rql, params, shapes, options) {
-  const {
-    isExecuting,
-    results,
-    error,
-    command
-  } = useCommandExecutor(options);
-  useEffect6(() => {
-    command(rql, params, shapes);
-  }, [rql, params, command]);
-  return { isExecuting, results, error };
-}
-
-// src/hooks/use-admin-executor.ts
-import { useState as useState4, useCallback as useCallback3, useRef as useRef4, useEffect as useEffect7 } from "react";
-function useAdminExecutor(options) {
-  const { client } = useConnection(options?.connectionConfig);
-  const [state, setState] = useState4({
-    isExecuting: false,
-    results: void 0,
-    error: void 0,
-    executionTime: void 0
-  });
-  const clientRef = useRef4(client);
-  clientRef.current = client;
-  const isMountedRef = useRef4(false);
-  useEffect7(() => {
-    isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-    };
-  }, []);
-  const executionIdRef = useRef4(0);
-  const pendingRef = useRef4(null);
-  const admin = useCallback3(
-    (rql, params, shapes) => {
-      const currentClient = clientRef.current;
-      if (!currentClient) {
-        pendingRef.current = { rql, params, shapes };
-        setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-        return Promise.resolve();
-      }
-      pendingRef.current = null;
-      const thisExecution = ++executionIdRef.current;
-      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-      const startTime = Date.now();
-      return (async () => {
-        try {
-          const frameResults = await currentClient.admin(rql, params || null, shapes || []) || [];
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          const results = frameResults.map((frame) => {
-            if (Array.isArray(frame) && frame.length > 0) {
-              const firstRow = frame[0];
-              let columns = [];
-              const hasValueObjects = firstRow && typeof firstRow === "object" && Object.values(firstRow).some((v) => v && typeof v === "object" && "type" in v);
-              if (hasValueObjects) {
-                columns = Object.keys(firstRow).map((key) => {
-                  const value = firstRow[key];
-                  const dataType = value?.type || "Utf8";
-                  return {
-                    name: key,
-                    type: dataType,
-                    payload: []
-                  };
-                });
-              } else {
-                columns = Object.keys(firstRow).map((key) => ({
-                  name: key,
-                  type: "Utf8",
-                  payload: []
-                }));
-              }
-              return {
-                columns,
-                rows: frame,
-                executionTimeMs: executionTime
-              };
-            } else {
-              return {
-                columns: [],
-                rows: [],
-                executionTimeMs: executionTime,
-                rowsAffected: typeof frame === "number" ? frame : void 0
-              };
-            }
-          });
-          if (!isMountedRef.current) return;
-          setState({
-            isExecuting: false,
-            results,
-            error: void 0,
-            executionTime
-          });
-        } catch (err) {
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          let errorMessage = "Admin execution failed";
-          if (err instanceof Error) {
-            errorMessage = err.message;
-          } else if (typeof err === "string") {
-            errorMessage = err;
-          } else if (err && typeof err === "object" && "message" in err) {
-            errorMessage = err.message;
-          }
-          console.error("Admin execution failed:", errorMessage);
-          if (!isMountedRef.current) return;
-          setState((prev) => ({
-            ...prev,
-            isExecuting: false,
-            error: errorMessage,
-            executionTime
-          }));
-        }
-      })();
-    },
-    []
-    // stable — never recreates
-  );
-  useEffect7(() => {
-    if (client && pendingRef.current) {
-      const { rql, params, shapes } = pendingRef.current;
-      admin(rql, params, shapes);
+// src/use-query.ts
+import { useEffect as useEffect2 } from "react";
+import { entryKey as entryKey2 } from "@reifydb/store";
+function useQuery(rql, params, shape, options = {}) {
+  const store = useStore();
+  const { enabled = true } = options;
+  const key = entryKey2(rql, params, shape);
+  useEffect2(() => {
+    if (enabled) {
+      store.query(rql, params, shape).catch(() => void 0);
     }
-  }, [client, admin]);
-  const cancelAdmin = useCallback3(() => {
-    executionIdRef.current++;
-    setState((prev) => ({
-      ...prev,
-      isExecuting: false,
-      error: "Admin cancelled"
-    }));
-  }, []);
-  return {
-    isExecuting: state.isExecuting,
-    results: state.results,
-    error: state.error,
-    executionTime: state.executionTime,
-    admin,
-    cancelAdmin
-  };
+  }, [store, key, enabled]);
+  return useEntry(store, rql, params, shape);
 }
 
-// src/hooks/use-admin.ts
-import { useEffect as useEffect8, useMemo as useMemo3 } from "react";
-function useAdminOne(rql, params, shape, options) {
-  const {
-    isExecuting,
-    results,
-    error,
-    admin
-  } = useAdminExecutor(options);
-  useEffect8(() => {
-    const shapes = shape ? [shape] : void 0;
-    admin(rql, params, shapes);
-  }, [rql, params, admin]);
-  const result = useMemo3(() => {
-    return results && results.length > 0 ? results[0] : void 0;
-  }, [results]);
-  return { isExecuting, result, error };
-}
-function useAdminMany(rql, params, shapes, options) {
-  const {
-    isExecuting,
-    results,
-    error,
-    admin
-  } = useAdminExecutor(options);
-  useEffect8(() => {
-    admin(rql, params, shapes);
-  }, [rql, params, admin]);
-  return { isExecuting, results, error };
-}
-
-// src/hooks/use-subscription-executor.ts
-import { useState as useState5, useCallback as useCallback4, useRef as useRef5, useEffect as useEffect9 } from "react";
-function useSubscriptionExecutor(options) {
-  const { client } = useConnection(options?.connectionConfig);
-  const [state, setState] = useState5({
-    data: [],
-    changes: [],
-    isSubscribed: false,
-    isSubscribing: false,
-    error: void 0,
-    subscriptionId: void 0
-  });
-  const clientRef = useRef5(client);
-  const subscriptionIdRef = useRef5(void 0);
-  const rqlRef = useRef5(void 0);
-  const paramsRef = useRef5(void 0);
-  const shapeRef = useRef5(void 0);
-  const configRef = useRef5(void 0);
-  useEffect9(() => {
-    clientRef.current = client;
-  }, [client]);
-  const addChangeEvent = useCallback4((operation, rows) => {
-    setState((prev) => {
-      const newChange = {
-        operation,
-        rows,
-        timestamp: Date.now()
-      };
-      const newChanges = [...prev.changes, newChange];
-      return {
-        ...prev,
-        data: prev.data,
-        changes: newChanges
-      };
-    });
-  }, []);
-  const handleInsert = useCallback4((rows) => {
-    addChangeEvent("INSERT", rows);
-  }, [addChangeEvent]);
-  const handleUpdate = useCallback4((rows) => {
-    addChangeEvent("UPDATE", rows);
-  }, [addChangeEvent]);
-  const handleRemove = useCallback4((rows) => {
-    addChangeEvent("REMOVE", rows);
-  }, [addChangeEvent]);
-  const subscribe = useCallback4(async (rql, params, shape, config) => {
-    const currentClient = clientRef.current;
-    if (!currentClient) {
-      setState((prev) => ({ ...prev, error: "Client not connected" }));
-      return;
-    }
-    if (!("subscribe" in currentClient)) {
-      setState((prev) => ({ ...prev, error: "Subscriptions require a WebSocket connection" }));
-      return;
-    }
-    rqlRef.current = rql;
-    paramsRef.current = params;
-    shapeRef.current = shape;
-    configRef.current = config;
-    setState((prev) => ({
-      ...prev,
-      isSubscribing: true,
-      error: void 0
-    }));
+// src/use-runner.ts
+import { useCallback as useCallback2, useState } from "react";
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function useRunner(kind, shapes) {
+  const store = useStore();
+  const [pending, setPending] = useState(0);
+  const [error, setError] = useState(void 0);
+  const run = useCallback2(async (rql, params = null) => {
+    setPending((count) => count + 1);
     try {
-      const subId = await currentClient.subscribe(rql, params, shape, {
-        onInsert: handleInsert,
-        onUpdate: handleUpdate,
-        onRemove: handleRemove
-      }, config);
-      subscriptionIdRef.current = subId;
-      setState((prev) => ({
-        ...prev,
-        isSubscribing: false,
-        isSubscribed: true,
-        subscriptionId: subId
-      }));
-    } catch (err) {
-      setState((prev) => ({
-        ...prev,
-        isSubscribing: false,
-        error: err.message || "Subscription failed"
-      }));
+      const result = await store[kind](rql, params, shapes);
+      setError(void 0);
+      return result;
+    } catch (cause) {
+      setError(toError(cause));
+      throw cause;
+    } finally {
+      setPending((count) => count - 1);
     }
-  }, [handleInsert, handleUpdate, handleRemove]);
-  const unsubscribe = useCallback4(async () => {
-    const currentClient = clientRef.current;
-    if (!currentClient || !subscriptionIdRef.current) return;
-    if (!("unsubscribe" in currentClient)) return;
-    try {
-      await currentClient.unsubscribe(subscriptionIdRef.current);
-      subscriptionIdRef.current = void 0;
-      rqlRef.current = void 0;
-      paramsRef.current = void 0;
-      shapeRef.current = void 0;
-      configRef.current = void 0;
-      setState((prev) => ({
-        ...prev,
-        isSubscribed: false,
-        subscriptionId: void 0
-      }));
-    } catch (err) {
-      setState((prev) => ({
-        ...prev,
-        error: err.message || "Unsubscribe failed"
-      }));
-    }
-  }, []);
-  const clearChanges = useCallback4(() => {
-    setState((prev) => ({ ...prev, changes: [] }));
-  }, []);
-  const clearData = useCallback4(() => {
-    setState((prev) => ({ ...prev, data: [] }));
-  }, []);
-  useEffect9(() => {
-    return () => {
-      if (subscriptionIdRef.current && clientRef.current && "unsubscribe" in clientRef.current) {
-        clientRef.current.unsubscribe(subscriptionIdRef.current).catch(console.error);
-      }
-    };
-  }, []);
-  return {
-    state,
-    subscribe,
-    unsubscribe,
-    clearChanges,
-    clearData
-  };
+  }, [store, kind, shapes]);
+  return { run, isPending: pending > 0, error };
 }
 
-// src/hooks/use-subscription.ts
-import { useEffect as useEffect10, useMemo as useMemo4 } from "react";
-function useSubscription(rql, params, shape, options) {
-  const {
-    state,
-    subscribe,
-    unsubscribe
-  } = useSubscriptionExecutor(options);
-  const paramsKey = useMemo4(() => JSON.stringify(params), [params]);
-  const configKey = useMemo4(() => JSON.stringify(options?.config), [options?.config]);
-  useEffect10(() => {
-    if (options?.enabled === false) return;
-    subscribe(rql, params, shape, options?.config);
-    return () => {
-      unsubscribe();
-    };
-  }, [rql, paramsKey, shape, configKey, options?.enabled, subscribe, unsubscribe]);
-  return {
-    data: state.data,
-    changes: state.changes,
-    isSubscribed: state.isSubscribed,
-    isSubscribing: state.isSubscribing,
-    error: state.error,
-    subscriptionId: state.subscriptionId
-  };
+// src/use-command.ts
+function useCommand(shapes) {
+  return useRunner("command", shapes);
 }
 
-// src/hooks/use-catalog.ts
-import { useEffect as useEffect11, useState as useState6 } from "react";
-import { Shape } from "@reifydb/core";
-import { typeNameFromCode } from "@reifydb/client";
-var namespaceShape = Shape.object({
-  id: Shape.number(),
-  name: Shape.string()
-});
-var tableShape = Shape.object({
-  id: Shape.number(),
-  namespace_id: Shape.number(),
-  name: Shape.string(),
-  primary_key_id: Shape.number()
-});
-var viewShape = Shape.object({
-  id: Shape.number(),
-  namespace_id: Shape.number(),
-  name: Shape.string()
-});
-var columnShape = Shape.object({
-  id: Shape.number(),
-  object_id: Shape.number(),
-  object_type: Shape.number(),
-  name: Shape.string(),
-  type: Shape.number(),
-  position: Shape.number(),
-  auto_increment: Shape.boolean()
-});
-function toNumber(value) {
-  if (value === void 0 || value === null) return void 0;
-  const n = Number(value);
-  return Number.isNaN(n) ? void 0 : n;
-}
-function useCatalog() {
-  const { isExecuting, results, error, query } = useQueryExecutor();
-  const [shape, setShape] = useState6([]);
-  const [isLoading, setIsLoading] = useState6(true);
-  useEffect11(() => {
-    if (!query) return;
-    const fetchShape = async () => {
-      setIsLoading(true);
-      try {
-        await query(
-          `OUTPUT FROM system::namespaces; OUTPUT FROM system::tables; OUTPUT FROM system::views; OUTPUT FROM system::columns;`,
-          void 0,
-          [namespaceShape, tableShape, viewShape, columnShape]
-        );
-      } catch (err) {
-        console.error("Failed to fetch shape:", err);
-      }
-    };
-    fetchShape();
-  }, [query]);
-  useEffect11(() => {
-    if (!results || results.length < 4) {
-      setIsLoading(isExecuting);
-      return;
-    }
-    const tablesResult = results[1];
-    const viewsResult = results[2];
-    const columnsResult = results[3];
-    if (!tablesResult?.rows || !viewsResult?.rows || !columnsResult?.rows) {
-      setIsLoading(false);
-      return;
-    }
-    const namespacesResult = results[0];
-    const namespaces = namespacesResult.rows;
-    const tables = tablesResult.rows;
-    const views = viewsResult.rows;
-    const columns = columnsResult.rows;
-    const namespaceMap = /* @__PURE__ */ new Map();
-    namespaces.forEach((ns) => {
-      const id = toNumber(ns.id);
-      const name = ns.name?.valueOf();
-      if (id !== void 0 && name) {
-        namespaceMap.set(id, name);
-      }
-    });
-    const tableInfoMap = /* @__PURE__ */ new Map();
-    tables.forEach((table) => {
-      const tableId = toNumber(table.id);
-      const namespaceId = toNumber(table.namespaceId);
-      const tableName = table.name?.valueOf();
-      if (tableId === void 0 || !tableName || namespaceId === void 0) return;
-      const namespace = namespaceMap.get(namespaceId);
-      if (!namespace) return;
-      const fullTableName = `${namespace}::${tableName}`;
-      tableInfoMap.set(tableId, {
-        name: fullTableName,
-        columns: []
-      });
-    });
-    views.forEach((view) => {
-      const viewId = toNumber(view.id);
-      const namespaceId = toNumber(view.namespaceId);
-      const viewName = view.name?.valueOf();
-      if (viewId === void 0 || !viewName || namespaceId === void 0) return;
-      const namespace = namespaceMap.get(namespaceId);
-      if (!namespace) return;
-      const fullViewName = `${namespace}::${viewName}`;
-      tableInfoMap.set(viewId, {
-        name: fullViewName,
-        columns: []
-      });
-    });
-    const tableColumnsMap = /* @__PURE__ */ new Map();
-    columns.forEach((column) => {
-      const objectId = toNumber(column.objectId);
-      const objectType = toNumber(column.objectType);
-      const columnName = column.name?.valueOf();
-      const typeId = toNumber(column.type);
-      const position = toNumber(column.position);
-      if (objectId === void 0 || !columnName || typeId === void 0) return;
-      if (objectType !== 0 && objectType !== 1) return;
-      if (!tableColumnsMap.has(objectId)) {
-        tableColumnsMap.set(objectId, []);
-      }
-      let dataType;
-      try {
-        dataType = typeNameFromCode(typeId);
-      } catch {
-        dataType = `Unknown(${typeId})`;
-      }
-      tableColumnsMap.get(objectId).push({
-        name: columnName,
-        dataType,
-        position: position ?? 0
-      });
-    });
-    tableColumnsMap.forEach((cols, objectId) => {
-      const tableInfo = tableInfoMap.get(objectId);
-      if (tableInfo) {
-        cols.sort((a, b) => a.position - b.position);
-        tableInfo.columns = cols.map((c) => ({ name: c.name, dataType: c.dataType }));
-      }
-    });
-    const shapeArray = Array.from(tableInfoMap.values()).filter((table) => table.name !== "reifydb::flows").sort((a, b) => a.name.localeCompare(b.name));
-    setShape(shapeArray);
-    setIsLoading(false);
-  }, [results, isExecuting]);
-  return [isLoading, shape, error];
+// src/use-admin.ts
+function useAdmin(shapes) {
+  return useRunner("admin", shapes);
 }
 export {
-  Connection,
-  ConnectionContext,
-  ConnectionProvider,
-  DEFAULT_CONFIG,
-  DEFAULT_URL,
-  clearConnection,
-  getConnection,
-  useAdminExecutor,
-  useAdminMany,
-  useAdminOne,
-  useCatalog,
-  useCommandExecutor,
-  useCommandMany,
-  useCommandOne,
-  useConnection,
-  useQueryExecutor,
-  useQueryMany,
-  useQueryOne,
-  useSubscription,
-  useSubscriptionExecutor
+  StoreProvider,
+  useAdmin,
+  useCommand,
+  useQuery,
+  useStore,
+  useSubscription
 };
 //# sourceMappingURL=index.js.map