@reifydb/react 0.8.1 → 0.9.1

package/dist/index.js

@@ -6,74 +6,74 @@ export * from "@reifydb/client";
 import { Client } from "@reifydb/client";
 var DEFAULT_CONFIG = {
   url: "ws://127.0.0.1:8090",
-  options: { timeout_ms: 3e4 }
+  options: { timeoutMs: 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,
+      isConnected: false,
+      isConnecting: false,
+      connectionError: null,
       listeners: /* @__PURE__ */ new Set()
     };
-    this.connect_promise = null;
+    this.connectPromise = null;
     this.config = { ...DEFAULT_CONFIG, ...config };
   }
-  set_config(config) {
+  setConfig(config) {
     this.config = config;
   }
-  get_config() {
+  getConfig() {
     return this.config;
   }
   async connect(url, options) {
-    if (this.state.is_connected) {
+    if (this.state.isConnected) {
       return;
     }
-    if (this.connect_promise) {
-      return this.connect_promise;
+    if (this.connectPromise) {
+      return this.connectPromise;
     }
-    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
+    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.connect_promise = (async () => {
+    this.connectPromise = (async () => {
       try {
-        const isHttp = connect_url.startsWith("http://") || connect_url.startsWith("https://");
+        const isHttp = connectUrl.startsWith("http://") || connectUrl.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);
+          client = isJson ? Client.connectJsonHttp(connectUrl, connectOptions) : Client.connectHttp(connectUrl, connectOptions);
         } else {
-          client = isJson ? await Client.connect_json_ws(connect_url, connect_options) : await Client.connect_ws(connect_url, connect_options);
+          client = isJson ? await Client.connectJsonWs(connectUrl, connectOptions) : await Client.connectWs(connectUrl, connectOptions);
         }
-        this.update_state({
+        this.updateState({
           client,
-          is_connected: true,
-          is_connecting: false,
-          connection_error: null
+          isConnected: true,
+          isConnecting: false,
+          connectionError: 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({
+        const errorMessage = err instanceof Error ? err.message : "Failed to connect to ReifyDB";
+        console.error("[Connection] Connection failed:", errorMessage, err);
+        this.updateState({
           client: null,
-          is_connected: false,
-          is_connecting: false,
-          connection_error: error_message
+          isConnected: false,
+          isConnecting: false,
+          connectionError: errorMessage
         });
         throw err;
       } finally {
-        this.connect_promise = null;
+        this.connectPromise = null;
       }
     })();
-    return this.connect_promise;
+    return this.connectPromise;
   }
   async disconnect() {
-    this.connect_promise = null;
+    this.connectPromise = null;
     if (this.state.client) {
       try {
         if ("disconnect" in this.state.client) {
@@ -83,30 +83,30 @@ var Connection = class {
         console.error("Error disconnecting:", err);
       }
     }
-    this.update_state({
+    this.updateState({
       client: null,
-      is_connected: false,
-      is_connecting: false,
-      connection_error: null
+      isConnected: false,
+      isConnecting: false,
+      connectionError: null
     });
   }
   async reconnect(url, options) {
     await this.disconnect();
     await this.connect(url, options);
   }
-  get_client() {
+  getClient() {
     return this.state.client;
   }
-  is_connected() {
-    return this.state.is_connected;
+  isConnected() {
+    return this.state.isConnected;
   }
-  is_connecting() {
-    return this.state.is_connecting;
+  isConnecting() {
+    return this.state.isConnecting;
   }
-  get_connection_error() {
-    return this.state.connection_error;
+  getConnectionError() {
+    return this.state.connectionError;
   }
-  get_state() {
+  getState() {
     const { listeners, ...state } = this.state;
     return state;
   }
@@ -117,7 +117,7 @@ var Connection = class {
       this.state.listeners.delete(listener);
     };
   }
-  update_state(updates) {
+  updateState(updates) {
     this.state = {
       ...this.state,
       ...updates
@@ -129,23 +129,23 @@ var Connection = class {
 };
 
 // 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) => {
+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) {
-    default_connection.set_config({ ...DEFAULT_CONFIG, ...config });
+    defaultConnection.setConfig({ ...DEFAULT_CONFIG, ...config });
   }
-  return default_connection;
+  return defaultConnection;
 }
-async function clear_connection() {
-  if (default_connection) {
-    await default_connection.disconnect();
-    default_connection = null;
+async function clearConnection() {
+  if (defaultConnection) {
+    await defaultConnection.disconnect();
+    defaultConnection = null;
   }
 }
 
@@ -153,48 +153,48 @@ async function clear_connection() {
 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);
+  const connection = getConnection(config);
+  const prevConfigRef = useRef(void 0);
+  const currentConfigStr = 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()) {
+    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.is_connected() && !connection.is_connecting()) {
+    } else if (!connection.isConnected() && !connection.isConnecting()) {
       connection.connect().catch((err) => {
         console.error("[ConnectionProvider] Failed to connect:", err);
       });
     }
-    prev_config_ref.current = current_config_str;
-  }, [current_config_str, connection]);
+    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(override_config) {
-  const context_connection = useContext(ConnectionContext);
+function useConnection(overrideConfig) {
+  const contextConnection = useContext(ConnectionContext);
   const [connection] = useState(() => {
-    if (override_config) {
-      return get_connection(override_config);
+    if (overrideConfig) {
+      return getConnection(overrideConfig);
     }
-    if (context_connection) {
-      return context_connection;
+    if (contextConnection) {
+      return contextConnection;
     }
-    return get_connection();
+    return getConnection();
   });
-  const [state, setState] = useState(() => connection.get_state());
+  const [state, setState] = useState(() => connection.getState());
   useEffect2(() => {
-    const current_state = connection.get_state();
-    setState(current_state);
-    const unsubscribe = connection.subscribe((new_state) => {
+    const currentState = connection.getState();
+    setState(currentState);
+    const unsubscribe = connection.subscribe((newState) => {
       setState({
-        client: new_state.client,
-        is_connected: new_state.is_connected,
-        is_connecting: new_state.is_connecting,
-        connection_error: new_state.connection_error
+        client: newState.client,
+        isConnected: newState.isConnected,
+        isConnecting: newState.isConnecting,
+        connectionError: newState.connectionError
       });
     });
     return unsubscribe;
@@ -210,57 +210,57 @@ function useConnection(override_config) {
 // 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 { client } = useConnection(options?.connectionConfig);
   const [state, setState] = useState2({
-    is_executing: false,
+    isExecuting: false,
     results: void 0,
     error: void 0,
-    execution_time: void 0
+    executionTime: void 0
   });
-  const client_ref = useRef2(client);
-  client_ref.current = client;
-  const is_mounted_ref = useRef2(true);
+  const clientRef = useRef2(client);
+  clientRef.current = client;
+  const isMountedRef = useRef2(true);
   useEffect3(() => {
     return () => {
-      is_mounted_ref.current = false;
+      isMountedRef.current = false;
     };
   }, []);
-  const execution_id_ref = useRef2(0);
-  const pending_ref = useRef2(null);
+  const executionIdRef = useRef2(0);
+  const pendingRef = 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 }));
+      const currentClient = clientRef.current;
+      if (!currentClient) {
+        pendingRef.current = { rql, params, shapes };
+        setState((prev) => ({ ...prev, isExecuting: 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();
+      pendingRef.current = null;
+      const thisExecution = ++executionIdRef.current;
+      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
+      const startTime = 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) => {
+          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 first_row = frame[0];
+              const firstRow = 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";
+              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: data_type,
+                    type: dataType,
                     payload: []
                   };
                 });
               } else {
-                columns = Object.keys(first_row).map((key) => ({
+                columns = Object.keys(firstRow).map((key) => ({
                   name: key,
                   type: "Utf8",
                   payload: []
@@ -269,41 +269,41 @@ function useQueryExecutor(options) {
               return {
                 columns,
                 rows: frame,
-                execution_time_ms: execution_time
+                executionTimeMs: executionTime
               };
             } else {
               return {
                 columns: [],
                 rows: [],
-                execution_time_ms: execution_time
+                executionTimeMs: executionTime
               };
             }
           });
-          if (!is_mounted_ref.current) return;
+          if (!isMountedRef.current) return;
           setState({
-            is_executing: false,
+            isExecuting: false,
             results,
             error: void 0,
-            execution_time
+            executionTime
           });
         } catch (err) {
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          let error_message = "Query execution failed";
+          if (executionIdRef.current !== thisExecution) return;
+          const executionTime = Date.now() - startTime;
+          let errorMessage = "Query execution failed";
           if (err instanceof Error) {
-            error_message = err.message;
+            errorMessage = err.message;
           } else if (typeof err === "string") {
-            error_message = err;
+            errorMessage = err;
           } else if (err && typeof err === "object" && "message" in err) {
-            error_message = err.message;
+            errorMessage = err.message;
           }
-          console.error("Query execution failed:", error_message);
-          if (!is_mounted_ref.current) return;
+          console.error("Query execution failed:", errorMessage);
+          if (!isMountedRef.current) return;
           setState((prev) => ({
             ...prev,
-            is_executing: false,
-            error: error_message,
-            execution_time
+            isExecuting: false,
+            error: errorMessage,
+            executionTime
           }));
         }
       })();
@@ -311,26 +311,26 @@ function useQueryExecutor(options) {
     []
   );
   useEffect3(() => {
-    if (client && pending_ref.current) {
-      const { rql, params, shapes } = pending_ref.current;
+    if (client && pendingRef.current) {
+      const { rql, params, shapes } = pendingRef.current;
       query(rql, params, shapes);
     }
   }, [client, query]);
-  const cancel_query = useCallback(() => {
-    execution_id_ref.current++;
+  const cancelQuery = useCallback(() => {
+    executionIdRef.current++;
     setState((prev) => ({
       ...prev,
-      is_executing: false,
+      isExecuting: false,
       error: "Query cancelled"
     }));
   }, []);
   return {
-    is_executing: state.is_executing,
+    isExecuting: state.isExecuting,
     results: state.results,
     error: state.error,
-    execution_time: state.execution_time,
+    executionTime: state.executionTime,
     query,
-    cancel_query
+    cancelQuery
   };
 }
 
@@ -338,7 +338,7 @@ function useQueryExecutor(options) {
 import { useEffect as useEffect4, useMemo } from "react";
 function useQueryOne(rql, params, shape, options) {
   const {
-    is_executing,
+    isExecuting,
     results,
     error,
     query
@@ -350,11 +350,11 @@ function useQueryOne(rql, params, shape, options) {
   const result = useMemo(() => {
     return results && results.length > 0 ? results[0] : void 0;
   }, [results]);
-  return { is_executing, result, error };
+  return { isExecuting, result, error };
 }
 function useQueryMany(rql, params, shapes, options) {
   const {
-    is_executing,
+    isExecuting,
     results,
     error,
     query
@@ -362,64 +362,64 @@ function useQueryMany(rql, params, shapes, options) {
   useEffect4(() => {
     query(rql, params, shapes);
   }, [rql, params, query]);
-  return { is_executing, results, error };
+  return { isExecuting, results, error };
 }
 
 // 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 { client } = useConnection(options?.connectionConfig);
   const [state, setState] = useState3({
-    is_executing: false,
+    isExecuting: false,
     results: void 0,
     error: void 0,
-    execution_time: void 0
+    executionTime: void 0
   });
-  const client_ref = useRef3(client);
-  client_ref.current = client;
-  const is_mounted_ref = useRef3(false);
+  const clientRef = useRef3(client);
+  clientRef.current = client;
+  const isMountedRef = useRef3(false);
   useEffect5(() => {
-    is_mounted_ref.current = true;
+    isMountedRef.current = true;
     return () => {
-      is_mounted_ref.current = false;
+      isMountedRef.current = false;
     };
   }, []);
-  const execution_id_ref = useRef3(0);
-  const pending_ref = useRef3(null);
+  const executionIdRef = useRef3(0);
+  const pendingRef = 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 }));
+      const currentClient = clientRef.current;
+      if (!currentClient) {
+        pendingRef.current = { rql, params, shapes };
+        setState((prev) => ({ ...prev, isExecuting: 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();
+      pendingRef.current = null;
+      const thisExecution = ++executionIdRef.current;
+      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
+      const startTime = 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) => {
+          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 first_row = frame[0];
+              const firstRow = 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";
+              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: data_type,
+                    type: dataType,
                     payload: []
                   };
                 });
               } else {
-                columns = Object.keys(first_row).map((key) => ({
+                columns = Object.keys(firstRow).map((key) => ({
                   name: key,
                   type: "Utf8",
                   payload: []
@@ -428,42 +428,42 @@ function useCommandExecutor(options) {
               return {
                 columns,
                 rows: frame,
-                execution_time_ms: execution_time
+                executionTimeMs: executionTime
               };
             } else {
               return {
                 columns: [],
                 rows: [],
-                execution_time_ms: execution_time,
-                rows_affected: typeof frame === "number" ? frame : void 0
+                executionTimeMs: executionTime,
+                rowsAffected: typeof frame === "number" ? frame : void 0
               };
             }
           });
-          if (!is_mounted_ref.current) return;
+          if (!isMountedRef.current) return;
           setState({
-            is_executing: false,
+            isExecuting: false,
             results,
             error: void 0,
-            execution_time
+            executionTime
           });
         } catch (err) {
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          let error_message = "Command execution failed";
+          if (executionIdRef.current !== thisExecution) return;
+          const executionTime = Date.now() - startTime;
+          let errorMessage = "Command execution failed";
           if (err instanceof Error) {
-            error_message = err.message;
+            errorMessage = err.message;
           } else if (typeof err === "string") {
-            error_message = err;
+            errorMessage = err;
           } else if (err && typeof err === "object" && "message" in err) {
-            error_message = err.message;
+            errorMessage = err.message;
           }
-          console.error("Command execution failed:", error_message);
-          if (!is_mounted_ref.current) return;
+          console.error("Command execution failed:", errorMessage);
+          if (!isMountedRef.current) return;
           setState((prev) => ({
             ...prev,
-            is_executing: false,
-            error: error_message,
-            execution_time
+            isExecuting: false,
+            error: errorMessage,
+            executionTime
           }));
         }
       })();
@@ -471,26 +471,26 @@ function useCommandExecutor(options) {
     []
   );
   useEffect5(() => {
-    if (client && pending_ref.current) {
-      const { rql, params, shapes } = pending_ref.current;
+    if (client && pendingRef.current) {
+      const { rql, params, shapes } = pendingRef.current;
       command(rql, params, shapes);
     }
   }, [client, command]);
-  const cancel_command = useCallback2(() => {
-    execution_id_ref.current++;
+  const cancelCommand = useCallback2(() => {
+    executionIdRef.current++;
     setState((prev) => ({
       ...prev,
-      is_executing: false,
+      isExecuting: false,
       error: "Command cancelled"
     }));
   }, []);
   return {
-    is_executing: state.is_executing,
+    isExecuting: state.isExecuting,
     results: state.results,
     error: state.error,
-    execution_time: state.execution_time,
+    executionTime: state.executionTime,
     command,
-    cancel_command
+    cancelCommand
   };
 }
 
@@ -498,7 +498,7 @@ function useCommandExecutor(options) {
 import { useEffect as useEffect6, useMemo as useMemo2 } from "react";
 function useCommandOne(rql, params, shape, options) {
   const {
-    is_executing,
+    isExecuting,
     results,
     error,
     command
@@ -510,11 +510,11 @@ function useCommandOne(rql, params, shape, options) {
   const result = useMemo2(() => {
     return results && results.length > 0 ? results[0] : void 0;
   }, [results]);
-  return { is_executing, result, error };
+  return { isExecuting, result, error };
 }
 function useCommandMany(rql, params, shapes, options) {
   const {
-    is_executing,
+    isExecuting,
     results,
     error,
     command
@@ -522,64 +522,64 @@ function useCommandMany(rql, params, shapes, options) {
   useEffect6(() => {
     command(rql, params, shapes);
   }, [rql, params, command]);
-  return { is_executing, results, error };
+  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?.connection_config);
+  const { client } = useConnection(options?.connectionConfig);
   const [state, setState] = useState4({
-    is_executing: false,
+    isExecuting: false,
     results: void 0,
     error: void 0,
-    execution_time: void 0
+    executionTime: void 0
   });
-  const client_ref = useRef4(client);
-  client_ref.current = client;
-  const is_mounted_ref = useRef4(false);
+  const clientRef = useRef4(client);
+  clientRef.current = client;
+  const isMountedRef = useRef4(false);
   useEffect7(() => {
-    is_mounted_ref.current = true;
+    isMountedRef.current = true;
     return () => {
-      is_mounted_ref.current = false;
+      isMountedRef.current = false;
     };
   }, []);
-  const execution_id_ref = useRef4(0);
-  const pending_ref = useRef4(null);
+  const executionIdRef = useRef4(0);
+  const pendingRef = 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 }));
+      const currentClient = clientRef.current;
+      if (!currentClient) {
+        pendingRef.current = { rql, params, shapes };
+        setState((prev) => ({ ...prev, isExecuting: 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();
+      pendingRef.current = null;
+      const thisExecution = ++executionIdRef.current;
+      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
+      const startTime = 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) => {
+          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 first_row = frame[0];
+              const firstRow = 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";
+              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: data_type,
+                    type: dataType,
                     payload: []
                   };
                 });
               } else {
-                columns = Object.keys(first_row).map((key) => ({
+                columns = Object.keys(firstRow).map((key) => ({
                   name: key,
                   type: "Utf8",
                   payload: []
@@ -588,42 +588,42 @@ function useAdminExecutor(options) {
               return {
                 columns,
                 rows: frame,
-                execution_time_ms: execution_time
+                executionTimeMs: executionTime
               };
             } else {
               return {
                 columns: [],
                 rows: [],
-                execution_time_ms: execution_time,
-                rows_affected: typeof frame === "number" ? frame : void 0
+                executionTimeMs: executionTime,
+                rowsAffected: typeof frame === "number" ? frame : void 0
               };
             }
           });
-          if (!is_mounted_ref.current) return;
+          if (!isMountedRef.current) return;
           setState({
-            is_executing: false,
+            isExecuting: false,
             results,
             error: void 0,
-            execution_time
+            executionTime
           });
         } catch (err) {
-          if (execution_id_ref.current !== this_execution) return;
-          const execution_time = Date.now() - start_time;
-          let error_message = "Admin execution failed";
+          if (executionIdRef.current !== thisExecution) return;
+          const executionTime = Date.now() - startTime;
+          let errorMessage = "Admin execution failed";
           if (err instanceof Error) {
-            error_message = err.message;
+            errorMessage = err.message;
           } else if (typeof err === "string") {
-            error_message = err;
+            errorMessage = err;
           } else if (err && typeof err === "object" && "message" in err) {
-            error_message = err.message;
+            errorMessage = err.message;
           }
-          console.error("Admin execution failed:", error_message);
-          if (!is_mounted_ref.current) return;
+          console.error("Admin execution failed:", errorMessage);
+          if (!isMountedRef.current) return;
           setState((prev) => ({
             ...prev,
-            is_executing: false,
-            error: error_message,
-            execution_time
+            isExecuting: false,
+            error: errorMessage,
+            executionTime
           }));
         }
       })();
@@ -632,26 +632,26 @@ function useAdminExecutor(options) {
     // stable — never recreates
   );
   useEffect7(() => {
-    if (client && pending_ref.current) {
-      const { rql, params, shapes } = pending_ref.current;
+    if (client && pendingRef.current) {
+      const { rql, params, shapes } = pendingRef.current;
       admin(rql, params, shapes);
     }
   }, [client, admin]);
-  const cancel_admin = useCallback3(() => {
-    execution_id_ref.current++;
+  const cancelAdmin = useCallback3(() => {
+    executionIdRef.current++;
     setState((prev) => ({
       ...prev,
-      is_executing: false,
+      isExecuting: false,
       error: "Admin cancelled"
     }));
   }, []);
   return {
-    is_executing: state.is_executing,
+    isExecuting: state.isExecuting,
     results: state.results,
     error: state.error,
-    execution_time: state.execution_time,
+    executionTime: state.executionTime,
     admin,
-    cancel_admin
+    cancelAdmin
   };
 }
 
@@ -659,7 +659,7 @@ function useAdminExecutor(options) {
 import { useEffect as useEffect8, useMemo as useMemo3 } from "react";
 function useAdminOne(rql, params, shape, options) {
   const {
-    is_executing,
+    isExecuting,
     results,
     error,
     admin
@@ -671,11 +671,11 @@ function useAdminOne(rql, params, shape, options) {
   const result = useMemo3(() => {
     return results && results.length > 0 ? results[0] : void 0;
   }, [results]);
-  return { is_executing, result, error };
+  return { isExecuting, result, error };
 }
 function useAdminMany(rql, params, shapes, options) {
   const {
-    is_executing,
+    isExecuting,
     results,
     error,
     admin
@@ -683,109 +683,109 @@ function useAdminMany(rql, params, shapes, options) {
   useEffect8(() => {
     admin(rql, params, shapes);
   }, [rql, params, admin]);
-  return { is_executing, results, error };
+  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?.connection_config);
+  const { client } = useConnection(options?.connectionConfig);
   const [state, setState] = useState5({
     data: [],
     changes: [],
-    is_subscribed: false,
-    is_subscribing: false,
+    isSubscribed: false,
+    isSubscribing: false,
     error: void 0,
-    subscription_id: void 0
+    subscriptionId: void 0
   });
-  const client_ref = useRef5(client);
+  const clientRef = 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);
+  const rqlRef = useRef5(void 0);
+  const paramsRef = useRef5(void 0);
+  const shapeRef = useRef5(void 0);
+  const configRef = useRef5(void 0);
   useEffect9(() => {
-    client_ref.current = client;
+    clientRef.current = client;
   }, [client]);
-  const add_change_event = useCallback4((operation, rows) => {
+  const addChangeEvent = useCallback4((operation, rows) => {
     setState((prev) => {
-      const new_change = {
+      const newChange = {
         operation,
         rows,
         timestamp: Date.now()
       };
-      const new_changes = [...prev.changes, new_change];
+      const newChanges = [...prev.changes, newChange];
       return {
         ...prev,
         data: prev.data,
-        changes: new_changes
+        changes: newChanges
       };
     });
   }, []);
-  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 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 current_client = client_ref.current;
-    if (!current_client) {
+    const currentClient = clientRef.current;
+    if (!currentClient) {
       setState((prev) => ({ ...prev, error: "Client not connected" }));
       return;
     }
-    if (!("subscribe" in current_client)) {
+    if (!("subscribe" in currentClient)) {
       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;
+    rqlRef.current = rql;
+    paramsRef.current = params;
+    shapeRef.current = shape;
+    configRef.current = config;
     setState((prev) => ({
       ...prev,
-      is_subscribing: true,
+      isSubscribing: true,
       error: void 0
     }));
     try {
-      const sub_id = await current_client.subscribe(rql, params, shape, {
-        on_insert: handle_insert,
-        on_update: handle_update,
-        on_remove: handle_remove
+      const subId = await currentClient.subscribe(rql, params, shape, {
+        onInsert: handleInsert,
+        onUpdate: handleUpdate,
+        onRemove: handleRemove
       }, config);
-      subscriptionIdRef.current = sub_id;
+      subscriptionIdRef.current = subId;
       setState((prev) => ({
         ...prev,
-        is_subscribing: false,
-        is_subscribed: true,
-        subscription_id: sub_id
+        isSubscribing: false,
+        isSubscribed: true,
+        subscriptionId: subId
       }));
     } catch (err) {
       setState((prev) => ({
         ...prev,
-        is_subscribing: false,
+        isSubscribing: false,
         error: err.message || "Subscription failed"
       }));
     }
-  }, [handle_insert, handle_update, handle_remove]);
+  }, [handleInsert, handleUpdate, handleRemove]);
   const unsubscribe = useCallback4(async () => {
-    const current_client = client_ref.current;
-    if (!current_client || !subscriptionIdRef.current) return;
-    if (!("unsubscribe" in current_client)) return;
+    const currentClient = clientRef.current;
+    if (!currentClient || !subscriptionIdRef.current) return;
+    if (!("unsubscribe" in currentClient)) return;
     try {
-      await current_client.unsubscribe(subscriptionIdRef.current);
+      await currentClient.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;
+      rqlRef.current = void 0;
+      paramsRef.current = void 0;
+      shapeRef.current = void 0;
+      configRef.current = void 0;
       setState((prev) => ({
         ...prev,
-        is_subscribed: false,
-        subscription_id: void 0
+        isSubscribed: false,
+        subscriptionId: void 0
       }));
     } catch (err) {
       setState((prev) => ({
@@ -794,16 +794,16 @@ function useSubscriptionExecutor(options) {
       }));
     }
   }, []);
-  const clear_changes = useCallback4(() => {
+  const clearChanges = useCallback4(() => {
     setState((prev) => ({ ...prev, changes: [] }));
   }, []);
-  const clear_data = useCallback4(() => {
+  const clearData = 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);
+      if (subscriptionIdRef.current && clientRef.current && "unsubscribe" in clientRef.current) {
+        clientRef.current.unsubscribe(subscriptionIdRef.current).catch(console.error);
       }
     };
   }, []);
@@ -811,8 +811,8 @@ function useSubscriptionExecutor(options) {
     state,
     subscribe,
     unsubscribe,
-    clear_changes,
-    clear_data
+    clearChanges,
+    clearData
   };
 }
 
@@ -824,166 +824,166 @@ function useSubscription(rql, params, shape, options) {
     subscribe,
     unsubscribe
   } = useSubscriptionExecutor(options);
-  const params_key = useMemo4(() => JSON.stringify(params), [params]);
-  const config_key = useMemo4(() => JSON.stringify(options?.config), [options?.config]);
+  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, params_key, shape, config_key, options?.enabled, subscribe, unsubscribe]);
+  }, [rql, paramsKey, shape, configKey, options?.enabled, subscribe, unsubscribe]);
   return {
     data: state.data,
     changes: state.changes,
-    is_subscribed: state.is_subscribed,
-    is_subscribing: state.is_subscribing,
+    isSubscribed: state.isSubscribed,
+    isSubscribing: state.isSubscribing,
     error: state.error,
-    subscription_id: state.subscription_id
+    subscriptionId: state.subscriptionId
   };
 }
 
-// src/hooks/use-shape.ts
+// 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({
+import { typeNameFromCode } from "@reifydb/client";
+var namespaceShape = Shape.object({
   id: Shape.number(),
   name: Shape.string()
 });
-var table_shape = Shape.object({
+var tableShape = Shape.object({
   id: Shape.number(),
   namespace_id: Shape.number(),
   name: Shape.string(),
   primary_key_id: Shape.number()
 });
-var view_shape = Shape.object({
+var viewShape = Shape.object({
   id: Shape.number(),
   namespace_id: Shape.number(),
   name: Shape.string()
 });
-var column_shape = Shape.object({
+var columnShape = Shape.object({
   id: Shape.number(),
-  shape_id: Shape.number(),
-  shape_type: 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) {
+function toNumber(value) {
   if (value === void 0 || value === null) return void 0;
   const n = Number(value);
   return Number.isNaN(n) ? void 0 : n;
 }
-function useShape() {
-  const { is_executing, results, error, query } = useQueryExecutor();
-  const [shape, set_shape] = useState6([]);
-  const [is_loading, set_is_loading] = useState6(true);
+function useCatalog() {
+  const { isExecuting, results, error, query } = useQueryExecutor();
+  const [shape, setShape] = useState6([]);
+  const [isLoading, setIsLoading] = useState6(true);
   useEffect11(() => {
     if (!query) return;
-    const fetch_shape = async () => {
-      set_is_loading(true);
+    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,
-          [namespace_shape, table_shape, view_shape, column_shape]
+          [namespaceShape, tableShape, viewShape, columnShape]
         );
       } catch (err) {
         console.error("Failed to fetch shape:", err);
       }
     };
-    fetch_shape();
+    fetchShape();
   }, [query]);
   useEffect11(() => {
     if (!results || results.length < 4) {
-      set_is_loading(is_executing);
+      setIsLoading(isExecuting);
       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);
+    const tablesResult = results[1];
+    const viewsResult = results[2];
+    const columnsResult = results[3];
+    if (!tablesResult?.rows || !viewsResult?.rows || !columnsResult?.rows) {
+      setIsLoading(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();
+    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 = to_number(ns.id);
+      const id = toNumber(ns.id);
       const name = ns.name?.valueOf();
       if (id !== void 0 && name) {
-        namespace_map.set(id, name);
+        namespaceMap.set(id, name);
       }
     });
-    const table_info_map = /* @__PURE__ */ new Map();
+    const tableInfoMap = /* @__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);
+      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 full_table_name = `${namespace}::${table_name}`;
-      table_info_map.set(table_id, {
-        name: full_table_name,
+      const fullTableName = `${namespace}::${tableName}`;
+      tableInfoMap.set(tableId, {
+        name: fullTableName,
         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);
+      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 full_view_name = `${namespace}::${view_name}`;
-      table_info_map.set(view_id, {
-        name: full_view_name,
+      const fullViewName = `${namespace}::${viewName}`;
+      tableInfoMap.set(viewId, {
+        name: fullViewName,
         columns: []
       });
     });
-    const table_columns_map = /* @__PURE__ */ new Map();
+    const tableColumnsMap = /* @__PURE__ */ new Map();
     columns.forEach((column) => {
-      const shape_id = to_number(column.shape_id);
-      const shape_type = to_number(column.shape_type);
-      const column_name = column.name?.valueOf();
-      const type_id = to_number(column.type);
-      const position = to_number(column.position);
-      if (shape_id === void 0 || !column_name || type_id === void 0) return;
-      if (shape_type !== 0 && shape_type !== 1) return;
-      if (!table_columns_map.has(shape_id)) {
-        table_columns_map.set(shape_id, []);
+      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 data_type;
+      let dataType;
       try {
-        data_type = type_name_from_code(type_id);
+        dataType = typeNameFromCode(typeId);
       } catch {
-        data_type = `Unknown(${type_id})`;
+        dataType = `Unknown(${typeId})`;
       }
-      table_columns_map.get(shape_id).push({
-        name: column_name,
-        data_type,
+      tableColumnsMap.get(objectId).push({
+        name: columnName,
+        dataType,
         position: position ?? 0
       });
     });
-    table_columns_map.forEach((cols, shape_id) => {
-      const table_info = table_info_map.get(shape_id);
-      if (table_info) {
+    tableColumnsMap.forEach((cols, objectId) => {
+      const tableInfo = tableInfoMap.get(objectId);
+      if (tableInfo) {
         cols.sort((a, b) => a.position - b.position);
-        table_info.columns = cols.map((c) => ({ name: c.name, data_type: c.data_type }));
+        tableInfo.columns = cols.map((c) => ({ name: c.name, dataType: c.dataType }));
       }
     });
-    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];
+    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];
 }
 export {
   Connection,
@@ -991,11 +991,12 @@ export {
   ConnectionProvider,
   DEFAULT_CONFIG,
   DEFAULT_URL,
-  clear_connection,
-  get_connection,
+  clearConnection,
+  getConnection,
   useAdminExecutor,
   useAdminMany,
   useAdminOne,
+  useCatalog,
   useCommandExecutor,
   useCommandMany,
   useCommandOne,
@@ -1003,7 +1004,6 @@ export {
   useQueryExecutor,
   useQueryMany,
   useQueryOne,
-  useShape,
   useSubscription,
   useSubscriptionExecutor
 };