@reifydb/react 0.9.0 → 0.9.2

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: { timeout_ms: 3e4 }
-};
-var DEFAULT_URL = "ws://127.0.0.1:8090";
-var Connection = class {
-  constructor(config = DEFAULT_CONFIG) {
-    this.state = {
-      client: null,
-      is_connected: false,
-      is_connecting: false,
-      connection_error: null,
-      listeners: /* @__PURE__ */ new Set()
-    };
-    this.connect_promise = null;
-    this.config = { ...DEFAULT_CONFIG, ...config };
-  }
-  set_config(config) {
-    this.config = config;
-  }
-  get_config() {
-    return this.config;
-  }
-  async connect(url, options) {
-    if (this.state.is_connected) {
-      return;
-    }
-    if (this.connect_promise) {
-      return this.connect_promise;
-    }
-    const connect_url = url || this.config.url || DEFAULT_CONFIG.url;
-    const connect_options = { token: this.config.token, ...this.config.options, ...options };
-    this.update_state({
-      is_connecting: true,
-      connection_error: null
-    });
-    this.connect_promise = (async () => {
-      try {
-        const isHttp = connect_url.startsWith("http://") || connect_url.startsWith("https://");
-        const isJson = this.config.format === "json";
-        let client;
-        if (isHttp) {
-          client = isJson ? Client.connect_json_http(connect_url, connect_options) : Client.connect_http(connect_url, connect_options);
-        } else {
-          client = isJson ? await Client.connect_json_ws(connect_url, connect_options) : await Client.connect_ws(connect_url, connect_options);
-        }
-        this.update_state({
-          client,
-          is_connected: true,
-          is_connecting: false,
-          connection_error: null
-        });
-      } catch (err) {
-        const error_message = err instanceof Error ? err.message : "Failed to connect to ReifyDB";
-        console.error("[Connection] Connection failed:", error_message, err);
-        this.update_state({
-          client: null,
-          is_connected: false,
-          is_connecting: false,
-          connection_error: error_message
-        });
-        throw err;
-      } finally {
-        this.connect_promise = null;
-      }
-    })();
-    return this.connect_promise;
-  }
-  async disconnect() {
-    this.connect_promise = 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.update_state({
-      client: null,
-      is_connected: false,
-      is_connecting: false,
-      connection_error: null
-    });
-  }
-  async reconnect(url, options) {
-    await this.disconnect();
-    await this.connect(url, options);
-  }
-  get_client() {
-    return this.state.client;
-  }
-  is_connected() {
-    return this.state.is_connected;
-  }
-  is_connecting() {
-    return this.state.is_connecting;
-  }
-  get_connection_error() {
-    return this.state.connection_error;
+// 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");
   }
-  get_state() {
-    const { listeners, ...state } = this.state;
-    return state;
-  }
-  // Subscribe to state changes
-  subscribe(listener) {
-    this.state.listeners.add(listener);
-    return () => {
-      this.state.listeners.delete(listener);
-    };
-  }
-  update_state(updates) {
-    this.state = {
-      ...this.state,
-      ...updates
-    };
-    this.state.listeners.forEach((listener) => {
-      listener(this.state);
-    });
-  }
-};
-
-// src/connection/connection-pool.ts
-var default_connection = null;
-function get_connection(config) {
-  if (!default_connection) {
-    const merged_config = { ...DEFAULT_CONFIG, ...config };
-    default_connection = new Connection(merged_config);
-    default_connection.connect().catch((err) => {
-      console.error("[ConnectionPool] Eager connect failed:", err);
-    });
-  } else if (config) {
-    default_connection.set_config({ ...DEFAULT_CONFIG, ...config });
-  }
-  return default_connection;
-}
-async function clear_connection() {
-  if (default_connection) {
-    await default_connection.disconnect();
-    default_connection = null;
-  }
-}
-
-// src/connection/connection-context.tsx
-import React, { createContext, useEffect, useRef } from "react";
-var ConnectionContext = createContext(null);
-function ConnectionProvider({ config, children }) {
-  const connection = get_connection(config);
-  const prev_config_ref = useRef(void 0);
-  const current_config_str = JSON.stringify(config);
-  useEffect(() => {
-    const config_changed = prev_config_ref.current !== void 0 && prev_config_ref.current !== current_config_str;
-    if (config_changed && connection.is_connected()) {
-      connection.reconnect().catch((err) => {
-        console.error("[ConnectionProvider] Failed to reconnect:", err);
-      });
-    } else if (!connection.is_connected() && !connection.is_connecting()) {
-      connection.connect().catch((err) => {
-        console.error("[ConnectionProvider] Failed to connect:", err);
-      });
-    }
-    prev_config_ref.current = current_config_str;
-  }, [current_config_str, 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(override_config) {
-  const context_connection = useContext(ConnectionContext);
-  const [connection] = useState(() => {
-    if (override_config) {
-      return get_connection(override_config);
-    }
-    if (context_connection) {
-      return context_connection;
-    }
-    return get_connection();
-  });
-  const [state, setState] = useState(() => connection.get_state());
-  useEffect2(() => {
-    const current_state = connection.get_state();
-    setState(current_state);
-    const unsubscribe = connection.subscribe((new_state) => {
-      setState({
-        client: new_state.client,
-        is_connected: new_state.is_connected,
-        is_connecting: new_state.is_connecting,
-        connection_error: new_state.connection_error
-      });
-    });
-    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?.connection_config);
-  const [state, setState] = useState2({
-    is_executing: false,
-    results: void 0,
-    error: void 0,
-    execution_time: void 0
-  });
-  const client_ref = useRef2(client);
-  client_ref.current = client;
-  const is_mounted_ref = useRef2(true);
-  useEffect3(() => {
-    return () => {
-      is_mounted_ref.current = false;
-    };
-  }, []);
-  const execution_id_ref = useRef2(0);
-  const pending_ref = useRef2(null);
-  const query = useCallback(
-    (rql, params, shapes) => {
-      const current_client = client_ref.current;
-      if (!current_client) {
-        pending_ref.current = { rql, params, shapes };
-        setState((prev) => ({ ...prev, is_executing: true, error: void 0 }));
-        return Promise.resolve();
-      }
-      pending_ref.current = null;
-      const this_execution = ++execution_id_ref.current;
-      setState((prev) => ({ ...prev, is_executing: true, error: void 0 }));
-      const start_time = Date.now();
-      return (async () => {
-        try {
-          const frame_results = await current_client.query(rql, params || null, shapes || []) || [];
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          const results = frame_results.map((frame) => {
-            if (Array.isArray(frame) && frame.length > 0) {
-              const first_row = frame[0];
-              let columns = [];
-              const has_value_objects = first_row && typeof first_row === "object" && Object.values(first_row).some((v) => v && typeof v === "object" && "type" in v);
-              if (has_value_objects) {
-                columns = Object.keys(first_row).map((key) => {
-                  const value = first_row[key];
-                  const data_type = value?.type || "Utf8";
-                  return {
-                    name: key,
-                    type: data_type,
-                    payload: []
-                  };
-                });
-              } else {
-                columns = Object.keys(first_row).map((key) => ({
-                  name: key,
-                  type: "Utf8",
-                  payload: []
-                }));
-              }
-              return {
-                columns,
-                rows: frame,
-                execution_time_ms: execution_time
-              };
-            } else {
-              return {
-                columns: [],
-                rows: [],
-                execution_time_ms: execution_time
-              };
-            }
-          });
-          if (!is_mounted_ref.current) return;
-          setState({
-            is_executing: false,
-            results,
-            error: void 0,
-            execution_time
-          });
-        } catch (err) {
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          let error_message = "Query execution failed";
-          if (err instanceof Error) {
-            error_message = err.message;
-          } else if (typeof err === "string") {
-            error_message = err;
-          } else if (err && typeof err === "object" && "message" in err) {
-            error_message = err.message;
-          }
-          console.error("Query execution failed:", error_message);
-          if (!is_mounted_ref.current) return;
-          setState((prev) => ({
-            ...prev,
-            is_executing: false,
-            error: error_message,
-            execution_time
-          }));
-        }
-      })();
-    },
-    []
-  );
-  useEffect3(() => {
-    if (client && pending_ref.current) {
-      const { rql, params, shapes } = pending_ref.current;
-      query(rql, params, shapes);
-    }
-  }, [client, query]);
-  const cancel_query = useCallback(() => {
-    execution_id_ref.current++;
-    setState((prev) => ({
-      ...prev,
-      is_executing: false,
-      error: "Query cancelled"
-    }));
-  }, []);
-  return {
-    is_executing: state.is_executing,
-    results: state.results,
-    error: state.error,
-    execution_time: state.execution_time,
-    query,
-    cancel_query
-  };
-}
+// 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 {
-    is_executing,
-    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 { is_executing, result, error };
-}
-function useQueryMany(rql, params, shapes, options) {
-  const {
-    is_executing,
-    results,
-    error,
-    query
-  } = useQueryExecutor(options);
-  useEffect4(() => {
-    query(rql, params, shapes);
-  }, [rql, params, query]);
-  return { is_executing, 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?.connection_config);
-  const [state, setState] = useState3({
-    is_executing: false,
-    results: void 0,
-    error: void 0,
-    execution_time: void 0
-  });
-  const client_ref = useRef3(client);
-  client_ref.current = client;
-  const is_mounted_ref = useRef3(false);
-  useEffect5(() => {
-    is_mounted_ref.current = true;
-    return () => {
-      is_mounted_ref.current = false;
-    };
-  }, []);
-  const execution_id_ref = useRef3(0);
-  const pending_ref = useRef3(null);
-  const command = useCallback2(
-    (rql, params, shapes) => {
-      const current_client = client_ref.current;
-      if (!current_client) {
-        pending_ref.current = { rql, params, shapes };
-        setState((prev) => ({ ...prev, is_executing: true, error: void 0 }));
-        return Promise.resolve();
-      }
-      pending_ref.current = null;
-      const this_execution = ++execution_id_ref.current;
-      setState((prev) => ({ ...prev, is_executing: true, error: void 0 }));
-      const start_time = Date.now();
-      return (async () => {
-        try {
-          const frame_results = await current_client.command(rql, params || null, shapes || []) || [];
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          const results = frame_results.map((frame) => {
-            if (Array.isArray(frame) && frame.length > 0) {
-              const first_row = frame[0];
-              let columns = [];
-              const has_value_objects = first_row && typeof first_row === "object" && Object.values(first_row).some((v) => v && typeof v === "object" && "type" in v);
-              if (has_value_objects) {
-                columns = Object.keys(first_row).map((key) => {
-                  const value = first_row[key];
-                  const data_type = value?.type || "Utf8";
-                  return {
-                    name: key,
-                    type: data_type,
-                    payload: []
-                  };
-                });
-              } else {
-                columns = Object.keys(first_row).map((key) => ({
-                  name: key,
-                  type: "Utf8",
-                  payload: []
-                }));
-              }
-              return {
-                columns,
-                rows: frame,
-                execution_time_ms: execution_time
-              };
-            } else {
-              return {
-                columns: [],
-                rows: [],
-                execution_time_ms: execution_time,
-                rows_affected: typeof frame === "number" ? frame : void 0
-              };
-            }
-          });
-          if (!is_mounted_ref.current) return;
-          setState({
-            is_executing: false,
-            results,
-            error: void 0,
-            execution_time
-          });
-        } catch (err) {
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          let error_message = "Command execution failed";
-          if (err instanceof Error) {
-            error_message = err.message;
-          } else if (typeof err === "string") {
-            error_message = err;
-          } else if (err && typeof err === "object" && "message" in err) {
-            error_message = err.message;
-          }
-          console.error("Command execution failed:", error_message);
-          if (!is_mounted_ref.current) return;
-          setState((prev) => ({
-            ...prev,
-            is_executing: false,
-            error: error_message,
-            execution_time
-          }));
-        }
-      })();
-    },
-    []
-  );
-  useEffect5(() => {
-    if (client && pending_ref.current) {
-      const { rql, params, shapes } = pending_ref.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 cancel_command = useCallback2(() => {
-    execution_id_ref.current++;
-    setState((prev) => ({
-      ...prev,
-      is_executing: false,
-      error: "Command cancelled"
-    }));
-  }, []);
-  return {
-    is_executing: state.is_executing,
-    results: state.results,
-    error: state.error,
-    execution_time: state.execution_time,
-    command,
-    cancel_command
-  };
+    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 {
-    is_executing,
-    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 { is_executing, result, error };
-}
-function useCommandMany(rql, params, shapes, options) {
-  const {
-    is_executing,
-    results,
-    error,
-    command
-  } = useCommandExecutor(options);
-  useEffect6(() => {
-    command(rql, params, shapes);
-  }, [rql, params, command]);
-  return { is_executing, 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?.connection_config);
-  const [state, setState] = useState4({
-    is_executing: false,
-    results: void 0,
-    error: void 0,
-    execution_time: void 0
-  });
-  const client_ref = useRef4(client);
-  client_ref.current = client;
-  const is_mounted_ref = useRef4(false);
-  useEffect7(() => {
-    is_mounted_ref.current = true;
-    return () => {
-      is_mounted_ref.current = false;
-    };
-  }, []);
-  const execution_id_ref = useRef4(0);
-  const pending_ref = useRef4(null);
-  const admin = useCallback3(
-    (rql, params, shapes) => {
-      const current_client = client_ref.current;
-      if (!current_client) {
-        pending_ref.current = { rql, params, shapes };
-        setState((prev) => ({ ...prev, is_executing: true, error: void 0 }));
-        return Promise.resolve();
-      }
-      pending_ref.current = null;
-      const this_execution = ++execution_id_ref.current;
-      setState((prev) => ({ ...prev, is_executing: true, error: void 0 }));
-      const start_time = Date.now();
-      return (async () => {
-        try {
-          const frame_results = await current_client.admin(rql, params || null, shapes || []) || [];
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          const results = frame_results.map((frame) => {
-            if (Array.isArray(frame) && frame.length > 0) {
-              const first_row = frame[0];
-              let columns = [];
-              const has_value_objects = first_row && typeof first_row === "object" && Object.values(first_row).some((v) => v && typeof v === "object" && "type" in v);
-              if (has_value_objects) {
-                columns = Object.keys(first_row).map((key) => {
-                  const value = first_row[key];
-                  const data_type = value?.type || "Utf8";
-                  return {
-                    name: key,
-                    type: data_type,
-                    payload: []
-                  };
-                });
-              } else {
-                columns = Object.keys(first_row).map((key) => ({
-                  name: key,
-                  type: "Utf8",
-                  payload: []
-                }));
-              }
-              return {
-                columns,
-                rows: frame,
-                execution_time_ms: execution_time
-              };
-            } else {
-              return {
-                columns: [],
-                rows: [],
-                execution_time_ms: execution_time,
-                rows_affected: typeof frame === "number" ? frame : void 0
-              };
-            }
-          });
-          if (!is_mounted_ref.current) return;
-          setState({
-            is_executing: false,
-            results,
-            error: void 0,
-            execution_time
-          });
-        } catch (err) {
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          let error_message = "Admin execution failed";
-          if (err instanceof Error) {
-            error_message = err.message;
-          } else if (typeof err === "string") {
-            error_message = err;
-          } else if (err && typeof err === "object" && "message" in err) {
-            error_message = err.message;
-          }
-          console.error("Admin execution failed:", error_message);
-          if (!is_mounted_ref.current) return;
-          setState((prev) => ({
-            ...prev,
-            is_executing: false,
-            error: error_message,
-            execution_time
-          }));
-        }
-      })();
-    },
-    []
-    // stable — never recreates
-  );
-  useEffect7(() => {
-    if (client && pending_ref.current) {
-      const { rql, params, shapes } = pending_ref.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 cancel_admin = useCallback3(() => {
-    execution_id_ref.current++;
-    setState((prev) => ({
-      ...prev,
-      is_executing: false,
-      error: "Admin cancelled"
-    }));
-  }, []);
-  return {
-    is_executing: state.is_executing,
-    results: state.results,
-    error: state.error,
-    execution_time: state.execution_time,
-    admin,
-    cancel_admin
-  };
+  }, [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 {
-    is_executing,
-    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 { is_executing, result, error };
-}
-function useAdminMany(rql, params, shapes, options) {
-  const {
-    is_executing,
-    results,
-    error,
-    admin
-  } = useAdminExecutor(options);
-  useEffect8(() => {
-    admin(rql, params, shapes);
-  }, [rql, params, admin]);
-  return { is_executing, 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?.connection_config);
-  const [state, setState] = useState5({
-    data: [],
-    changes: [],
-    is_subscribed: false,
-    is_subscribing: false,
-    error: void 0,
-    subscription_id: void 0
-  });
-  const client_ref = useRef5(client);
-  const subscriptionIdRef = useRef5(void 0);
-  const rql_ref = useRef5(void 0);
-  const params_ref = useRef5(void 0);
-  const shape_ref = useRef5(void 0);
-  const config_ref = useRef5(void 0);
-  useEffect9(() => {
-    client_ref.current = client;
-  }, [client]);
-  const add_change_event = useCallback4((operation, rows) => {
-    setState((prev) => {
-      const new_change = {
-        operation,
-        rows,
-        timestamp: Date.now()
-      };
-      const new_changes = [...prev.changes, new_change];
-      return {
-        ...prev,
-        data: prev.data,
-        changes: new_changes
-      };
-    });
-  }, []);
-  const handle_insert = useCallback4((rows) => {
-    add_change_event("INSERT", rows);
-  }, [add_change_event]);
-  const handle_update = useCallback4((rows) => {
-    add_change_event("UPDATE", rows);
-  }, [add_change_event]);
-  const handle_remove = useCallback4((rows) => {
-    add_change_event("REMOVE", rows);
-  }, [add_change_event]);
-  const subscribe = useCallback4(async (rql, params, shape, config) => {
-    const current_client = client_ref.current;
-    if (!current_client) {
-      setState((prev) => ({ ...prev, error: "Client not connected" }));
-      return;
-    }
-    if (!("subscribe" in current_client)) {
-      setState((prev) => ({ ...prev, error: "Subscriptions require a WebSocket connection" }));
-      return;
-    }
-    rql_ref.current = rql;
-    params_ref.current = params;
-    shape_ref.current = shape;
-    config_ref.current = config;
-    setState((prev) => ({
-      ...prev,
-      is_subscribing: 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 sub_id = await current_client.subscribe(rql, params, shape, {
-        on_insert: handle_insert,
-        on_update: handle_update,
-        on_remove: handle_remove
-      }, config);
-      subscriptionIdRef.current = sub_id;
-      setState((prev) => ({
-        ...prev,
-        is_subscribing: false,
-        is_subscribed: true,
-        subscription_id: sub_id
-      }));
-    } catch (err) {
-      setState((prev) => ({
-        ...prev,
-        is_subscribing: 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);
     }
-  }, [handle_insert, handle_update, handle_remove]);
-  const unsubscribe = useCallback4(async () => {
-    const current_client = client_ref.current;
-    if (!current_client || !subscriptionIdRef.current) return;
-    if (!("unsubscribe" in current_client)) return;
-    try {
-      await current_client.unsubscribe(subscriptionIdRef.current);
-      subscriptionIdRef.current = void 0;
-      rql_ref.current = void 0;
-      params_ref.current = void 0;
-      shape_ref.current = void 0;
-      config_ref.current = void 0;
-      setState((prev) => ({
-        ...prev,
-        is_subscribed: false,
-        subscription_id: void 0
-      }));
-    } catch (err) {
-      setState((prev) => ({
-        ...prev,
-        error: err.message || "Unsubscribe failed"
-      }));
-    }
-  }, []);
-  const clear_changes = useCallback4(() => {
-    setState((prev) => ({ ...prev, changes: [] }));
-  }, []);
-  const clear_data = useCallback4(() => {
-    setState((prev) => ({ ...prev, data: [] }));
-  }, []);
-  useEffect9(() => {
-    return () => {
-      if (subscriptionIdRef.current && client_ref.current && "unsubscribe" in client_ref.current) {
-        client_ref.current.unsubscribe(subscriptionIdRef.current).catch(console.error);
-      }
-    };
-  }, []);
-  return {
-    state,
-    subscribe,
-    unsubscribe,
-    clear_changes,
-    clear_data
-  };
+  }, [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 params_key = useMemo4(() => JSON.stringify(params), [params]);
-  const config_key = useMemo4(() => JSON.stringify(options?.config), [options?.config]);
-  useEffect10(() => {
-    if (options?.enabled === false) return;
-    subscribe(rql, params, shape, options?.config);
-    return () => {
-      unsubscribe();
-    };
-  }, [rql, params_key, shape, config_key, options?.enabled, subscribe, unsubscribe]);
-  return {
-    data: state.data,
-    changes: state.changes,
-    is_subscribed: state.is_subscribed,
-    is_subscribing: state.is_subscribing,
-    error: state.error,
-    subscription_id: state.subscription_id
-  };
+// 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 { type_name_from_code } from "@reifydb/client";
-var namespace_shape = Shape.object({
-  id: Shape.number(),
-  name: Shape.string()
-});
-var table_shape = Shape.object({
-  id: Shape.number(),
-  namespace_id: Shape.number(),
-  name: Shape.string(),
-  primary_key_id: Shape.number()
-});
-var view_shape = Shape.object({
-  id: Shape.number(),
-  namespace_id: Shape.number(),
-  name: Shape.string()
-});
-var column_shape = 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 to_number(value) {
-  if (value === void 0 || value === null) return void 0;
-  const n = Number(value);
-  return Number.isNaN(n) ? void 0 : n;
-}
-function useCatalog() {
-  const { is_executing, results, error, query } = useQueryExecutor();
-  const [shape, set_shape] = useState6([]);
-  const [is_loading, set_is_loading] = useState6(true);
-  useEffect11(() => {
-    if (!query) return;
-    const fetch_shape = async () => {
-      set_is_loading(true);
-      try {
-        await query(
-          `OUTPUT FROM system::namespaces; OUTPUT FROM system::tables; OUTPUT FROM system::views; OUTPUT FROM system::columns;`,
-          void 0,
-          [namespace_shape, table_shape, view_shape, column_shape]
-        );
-      } catch (err) {
-        console.error("Failed to fetch shape:", err);
-      }
-    };
-    fetch_shape();
-  }, [query]);
-  useEffect11(() => {
-    if (!results || results.length < 4) {
-      set_is_loading(is_executing);
-      return;
-    }
-    const tables_result = results[1];
-    const views_result = results[2];
-    const columns_result = results[3];
-    if (!tables_result?.rows || !views_result?.rows || !columns_result?.rows) {
-      set_is_loading(false);
-      return;
-    }
-    const namespaces_result = results[0];
-    const namespaces = namespaces_result.rows;
-    const tables = tables_result.rows;
-    const views = views_result.rows;
-    const columns = columns_result.rows;
-    const namespace_map = /* @__PURE__ */ new Map();
-    namespaces.forEach((ns) => {
-      const id = to_number(ns.id);
-      const name = ns.name?.valueOf();
-      if (id !== void 0 && name) {
-        namespace_map.set(id, name);
-      }
-    });
-    const table_info_map = /* @__PURE__ */ new Map();
-    tables.forEach((table) => {
-      const table_id = to_number(table.id);
-      const namespace_id = to_number(table.namespace_id);
-      const table_name = table.name?.valueOf();
-      if (table_id === void 0 || !table_name || namespace_id === void 0) return;
-      const namespace = namespace_map.get(namespace_id);
-      if (!namespace) return;
-      const full_table_name = `${namespace}::${table_name}`;
-      table_info_map.set(table_id, {
-        name: full_table_name,
-        columns: []
-      });
-    });
-    views.forEach((view) => {
-      const view_id = to_number(view.id);
-      const namespace_id = to_number(view.namespace_id);
-      const view_name = view.name?.valueOf();
-      if (view_id === void 0 || !view_name || namespace_id === void 0) return;
-      const namespace = namespace_map.get(namespace_id);
-      if (!namespace) return;
-      const full_view_name = `${namespace}::${view_name}`;
-      table_info_map.set(view_id, {
-        name: full_view_name,
-        columns: []
-      });
-    });
-    const table_columns_map = /* @__PURE__ */ new Map();
-    columns.forEach((column) => {
-      const object_id = to_number(column.object_id);
-      const object_type = to_number(column.object_type);
-      const column_name = column.name?.valueOf();
-      const type_id = to_number(column.type);
-      const position = to_number(column.position);
-      if (object_id === void 0 || !column_name || type_id === void 0) return;
-      if (object_type !== 0 && object_type !== 1) return;
-      if (!table_columns_map.has(object_id)) {
-        table_columns_map.set(object_id, []);
-      }
-      let data_type;
-      try {
-        data_type = type_name_from_code(type_id);
-      } catch {
-        data_type = `Unknown(${type_id})`;
-      }
-      table_columns_map.get(object_id).push({
-        name: column_name,
-        data_type,
-        position: position ?? 0
-      });
-    });
-    table_columns_map.forEach((cols, object_id) => {
-      const table_info = table_info_map.get(object_id);
-      if (table_info) {
-        cols.sort((a, b) => a.position - b.position);
-        table_info.columns = cols.map((c) => ({ name: c.name, data_type: c.data_type }));
-      }
-    });
-    const shape_array = Array.from(table_info_map.values()).filter((table) => table.name !== "reifydb::flows").sort((a, b) => a.name.localeCompare(b.name));
-    set_shape(shape_array);
-    set_is_loading(false);
-  }, [results, is_executing]);
-  return [is_loading, shape, error];
+// src/use-admin.ts
+function useAdmin(shapes) {
+  return useRunner("admin", shapes);
 }
 export {
-  Connection,
-  ConnectionContext,
-  ConnectionProvider,
-  DEFAULT_CONFIG,
-  DEFAULT_URL,
-  clear_connection,
-  get_connection,
-  useAdminExecutor,
-  useAdminMany,
-  useAdminOne,
-  useCatalog,
-  useCommandExecutor,
-  useCommandMany,
-  useCommandOne,
-  useConnection,
-  useQueryExecutor,
-  useQueryMany,
-  useQueryOne,
-  useSubscription,
-  useSubscriptionExecutor
+  StoreProvider,
+  useAdmin,
+  useCommand,
+  useQuery,
+  useStore,
+  useSubscription
 };
 //# sourceMappingURL=index.js.map