@reifydb/react 0.4.9 → 0.4.11

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: { timeoutMs: 3e4 }
+  options: { timeout_ms: 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,
+      is_connected: false,
+      is_connecting: false,
+      connection_error: null,
       listeners: /* @__PURE__ */ new Set()
     };
-    this.connectPromise = null;
+    this.connect_promise = null;
     this.config = { ...DEFAULT_CONFIG, ...config };
   }
-  setConfig(config) {
+  set_config(config) {
     this.config = config;
   }
-  getConfig() {
+  get_config() {
     return this.config;
   }
   async connect(url, options) {
-    if (this.state.isConnected) {
+    if (this.state.is_connected) {
       return;
     }
-    if (this.connectPromise) {
-      return this.connectPromise;
+    if (this.connect_promise) {
+      return this.connect_promise;
     }
-    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
+    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.connectPromise = (async () => {
+    this.connect_promise = (async () => {
       try {
-        const isHttp = connectUrl.startsWith("http://") || connectUrl.startsWith("https://");
+        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(connectUrl, connectOptions) : Client.connect_http(connectUrl, connectOptions);
+          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(connectUrl, connectOptions) : await Client.connect_ws(connectUrl, connectOptions);
+          client = isJson ? await Client.connect_json_ws(connect_url, connect_options) : await Client.connect_ws(connect_url, connect_options);
         }
-        this.updateState({
+        this.update_state({
           client,
-          isConnected: true,
-          isConnecting: false,
-          connectionError: null
+          is_connected: true,
+          is_connecting: false,
+          connection_error: null
         });
       } catch (err) {
-        const errorMessage = err instanceof Error ? err.message : "Failed to connect to ReifyDB";
-        console.error("[Connection] Connection failed:", errorMessage, err);
-        this.updateState({
+        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,
-          isConnected: false,
-          isConnecting: false,
-          connectionError: errorMessage
+          is_connected: false,
+          is_connecting: false,
+          connection_error: error_message
         });
         throw err;
       } finally {
-        this.connectPromise = null;
+        this.connect_promise = null;
       }
     })();
-    return this.connectPromise;
+    return this.connect_promise;
   }
   async disconnect() {
-    this.connectPromise = null;
+    this.connect_promise = null;
     if (this.state.client) {
       try {
         if ("disconnect" in this.state.client) {
@@ -84,30 +84,30 @@ var Connection = class {
         console.error("Error disconnecting:", err);
       }
     }
-    this.updateState({
+    this.update_state({
       client: null,
-      isConnected: false,
-      isConnecting: false,
-      connectionError: null
+      is_connected: false,
+      is_connecting: false,
+      connection_error: null
     });
   }
   async reconnect(url, options) {
     await this.disconnect();
     await this.connect(url, options);
   }
-  getClient() {
+  get_client() {
     return this.state.client;
   }
-  isConnected() {
-    return this.state.isConnected;
+  is_connected() {
+    return this.state.is_connected;
   }
-  isConnecting() {
-    return this.state.isConnecting;
+  is_connecting() {
+    return this.state.is_connecting;
   }
-  getConnectionError() {
-    return this.state.connectionError;
+  get_connection_error() {
+    return this.state.connection_error;
   }
-  getState() {
+  get_state() {
     const { listeners, ...state } = this.state;
     return state;
   }
@@ -118,7 +118,7 @@ var Connection = class {
       this.state.listeners.delete(listener);
     };
   }
-  updateState(updates) {
+  update_state(updates) {
     this.state = {
       ...this.state,
       ...updates
@@ -130,23 +130,23 @@ var Connection = class {
 };
 
 // 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) => {
+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) {
-    defaultConnection.setConfig({ ...DEFAULT_CONFIG, ...config });
+    default_connection.set_config({ ...DEFAULT_CONFIG, ...config });
   }
-  return defaultConnection;
+  return default_connection;
 }
-async function clearConnection() {
-  if (defaultConnection) {
-    await defaultConnection.disconnect();
-    defaultConnection = null;
+async function clear_connection() {
+  if (default_connection) {
+    await default_connection.disconnect();
+    default_connection = null;
   }
 }
 
@@ -154,48 +154,48 @@ async function clearConnection() {
 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);
+  const connection = get_connection(config);
+  const prev_config_ref = useRef(void 0);
+  const current_config_str = JSON.stringify(config);
   useEffect(() => {
-    const configChanged = prevConfigRef.current !== void 0 && prevConfigRef.current !== currentConfigStr;
-    if (configChanged && connection.isConnected()) {
+    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.isConnected() && !connection.isConnecting()) {
+    } else if (!connection.is_connected() && !connection.is_connecting()) {
       connection.connect().catch((err) => {
         console.error("[ConnectionProvider] Failed to connect:", err);
       });
     }
-    prevConfigRef.current = currentConfigStr;
-  }, [currentConfigStr, connection]);
+    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(overrideConfig) {
-  const contextConnection = useContext(ConnectionContext);
+function useConnection(override_config) {
+  const context_connection = useContext(ConnectionContext);
   const [connection] = useState(() => {
-    if (overrideConfig) {
-      return getConnection(overrideConfig);
+    if (override_config) {
+      return get_connection(override_config);
     }
-    if (contextConnection) {
-      return contextConnection;
+    if (context_connection) {
+      return context_connection;
     }
-    return getConnection();
+    return get_connection();
   });
-  const [state, setState] = useState(() => connection.getState());
+  const [state, setState] = useState(() => connection.get_state());
   useEffect2(() => {
-    const currentState = connection.getState();
-    setState(currentState);
-    const unsubscribe = connection.subscribe((newState) => {
+    const current_state = connection.get_state();
+    setState(current_state);
+    const unsubscribe = connection.subscribe((new_state) => {
       setState({
-        client: newState.client,
-        isConnected: newState.isConnected,
-        isConnecting: newState.isConnecting,
-        connectionError: newState.connectionError
+        client: new_state.client,
+        is_connected: new_state.is_connected,
+        is_connecting: new_state.is_connecting,
+        connection_error: new_state.connection_error
       });
     });
     return unsubscribe;
@@ -211,57 +211,57 @@ function useConnection(overrideConfig) {
 // 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 { client } = useConnection(options?.connection_config);
   const [state, setState] = useState2({
-    isExecuting: false,
+    is_executing: false,
     results: void 0,
     error: void 0,
-    executionTime: void 0
+    execution_time: void 0
   });
-  const clientRef = useRef2(client);
-  clientRef.current = client;
-  const isMountedRef = useRef2(true);
+  const client_ref = useRef2(client);
+  client_ref.current = client;
+  const is_mounted_ref = useRef2(true);
   useEffect3(() => {
     return () => {
-      isMountedRef.current = false;
+      is_mounted_ref.current = false;
     };
   }, []);
-  const executionIdRef = useRef2(0);
-  const pendingRef = useRef2(null);
+  const execution_id_ref = useRef2(0);
+  const pending_ref = useRef2(null);
   const query = useCallback(
-    (statements, params, shapes) => {
-      const currentClient = clientRef.current;
-      if (!currentClient) {
-        pendingRef.current = { statements, params, shapes };
-        setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
+    (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();
       }
-      pendingRef.current = null;
-      const thisExecution = ++executionIdRef.current;
-      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-      const startTime = Date.now();
+      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 frameResults = await currentClient.query(statements, params || null, shapes || []) || [];
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          const results = frameResults.map((frame) => {
+          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 firstRow = frame[0];
+              const first_row = 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";
+              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: dataType,
+                    type: data_type,
                     payload: []
                   };
                 });
               } else {
-                columns = Object.keys(firstRow).map((key) => ({
+                columns = Object.keys(first_row).map((key) => ({
                   name: key,
                   type: "Utf8",
                   payload: []
@@ -270,41 +270,41 @@ function useQueryExecutor(options) {
               return {
                 columns,
                 rows: frame,
-                executionTimeMs: executionTime
+                execution_time_ms: execution_time
               };
             } else {
               return {
                 columns: [],
                 rows: [],
-                executionTimeMs: executionTime
+                execution_time_ms: execution_time
               };
             }
           });
-          if (!isMountedRef.current) return;
+          if (!is_mounted_ref.current) return;
           setState({
-            isExecuting: false,
+            is_executing: false,
             results,
             error: void 0,
-            executionTime
+            execution_time
           });
         } catch (err) {
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          let errorMessage = "Query execution failed";
+          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) {
-            errorMessage = err.message;
+            error_message = err.message;
           } else if (typeof err === "string") {
-            errorMessage = err;
+            error_message = err;
           } else if (err && typeof err === "object" && "message" in err) {
-            errorMessage = err.message;
+            error_message = err.message;
           }
-          console.error("Query execution failed:", errorMessage);
-          if (!isMountedRef.current) return;
+          console.error("Query execution failed:", error_message);
+          if (!is_mounted_ref.current) return;
           setState((prev) => ({
             ...prev,
-            isExecuting: false,
-            error: errorMessage,
-            executionTime
+            is_executing: false,
+            error: error_message,
+            execution_time
           }));
         }
       })();
@@ -312,26 +312,26 @@ function useQueryExecutor(options) {
     []
   );
   useEffect3(() => {
-    if (client && pendingRef.current) {
-      const { statements, params, shapes } = pendingRef.current;
-      query(statements, params, shapes);
+    if (client && pending_ref.current) {
+      const { rql, params, shapes } = pending_ref.current;
+      query(rql, params, shapes);
     }
   }, [client, query]);
-  const cancelQuery = useCallback(() => {
-    executionIdRef.current++;
+  const cancel_query = useCallback(() => {
+    execution_id_ref.current++;
     setState((prev) => ({
       ...prev,
-      isExecuting: false,
+      is_executing: false,
       error: "Query cancelled"
     }));
   }, []);
   return {
-    isExecuting: state.isExecuting,
+    is_executing: state.is_executing,
     results: state.results,
     error: state.error,
-    executionTime: state.executionTime,
+    execution_time: state.execution_time,
     query,
-    cancelQuery
+    cancel_query
   };
 }
 
@@ -339,7 +339,7 @@ function useQueryExecutor(options) {
 import { useEffect as useEffect4, useMemo } from "react";
 function useQueryOne(rql, params, shape, options) {
   const {
-    isExecuting,
+    is_executing,
     results,
     error,
     query
@@ -351,76 +351,76 @@ function useQueryOne(rql, params, shape, options) {
   const result = useMemo(() => {
     return results && results.length > 0 ? results[0] : void 0;
   }, [results]);
-  return { isExecuting, result, error };
+  return { is_executing, result, error };
 }
-function useQueryMany(statements, params, shapes, options) {
+function useQueryMany(rql, params, shapes, options) {
   const {
-    isExecuting,
+    is_executing,
     results,
     error,
     query
   } = useQueryExecutor(options);
   useEffect4(() => {
-    query(statements, params, shapes);
-  }, [statements, params, query]);
-  return { isExecuting, results, error };
+    query(rql, params, shapes);
+  }, [rql, params, query]);
+  return { is_executing, 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?.connectionConfig);
+  const { client } = useConnection(options?.connection_config);
   const [state, setState] = useState3({
-    isExecuting: false,
+    is_executing: false,
     results: void 0,
     error: void 0,
-    executionTime: void 0
+    execution_time: void 0
   });
-  const clientRef = useRef3(client);
-  clientRef.current = client;
-  const isMountedRef = useRef3(false);
+  const client_ref = useRef3(client);
+  client_ref.current = client;
+  const is_mounted_ref = useRef3(false);
   useEffect5(() => {
-    isMountedRef.current = true;
+    is_mounted_ref.current = true;
     return () => {
-      isMountedRef.current = false;
+      is_mounted_ref.current = false;
     };
   }, []);
-  const executionIdRef = useRef3(0);
-  const pendingRef = useRef3(null);
+  const execution_id_ref = useRef3(0);
+  const pending_ref = useRef3(null);
   const command = useCallback2(
-    (statements, params, shapes) => {
-      const currentClient = clientRef.current;
-      if (!currentClient) {
-        pendingRef.current = { statements, params, shapes };
-        setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
+    (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();
       }
-      pendingRef.current = null;
-      const thisExecution = ++executionIdRef.current;
-      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-      const startTime = Date.now();
+      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 frameResults = await currentClient.command(statements, params || null, shapes || []) || [];
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          const results = frameResults.map((frame) => {
+          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 firstRow = frame[0];
+              const first_row = 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";
+              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: dataType,
+                    type: data_type,
                     payload: []
                   };
                 });
               } else {
-                columns = Object.keys(firstRow).map((key) => ({
+                columns = Object.keys(first_row).map((key) => ({
                   name: key,
                   type: "Utf8",
                   payload: []
@@ -429,42 +429,42 @@ function useCommandExecutor(options) {
               return {
                 columns,
                 rows: frame,
-                executionTimeMs: executionTime
+                execution_time_ms: execution_time
               };
             } else {
               return {
                 columns: [],
                 rows: [],
-                executionTimeMs: executionTime,
-                rowsAffected: typeof frame === "number" ? frame : void 0
+                execution_time_ms: execution_time,
+                rows_affected: typeof frame === "number" ? frame : void 0
               };
             }
           });
-          if (!isMountedRef.current) return;
+          if (!is_mounted_ref.current) return;
           setState({
-            isExecuting: false,
+            is_executing: false,
             results,
             error: void 0,
-            executionTime
+            execution_time
           });
         } catch (err) {
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          let errorMessage = "Command execution failed";
+          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) {
-            errorMessage = err.message;
+            error_message = err.message;
           } else if (typeof err === "string") {
-            errorMessage = err;
+            error_message = err;
           } else if (err && typeof err === "object" && "message" in err) {
-            errorMessage = err.message;
+            error_message = err.message;
           }
-          console.error("Command execution failed:", errorMessage);
-          if (!isMountedRef.current) return;
+          console.error("Command execution failed:", error_message);
+          if (!is_mounted_ref.current) return;
           setState((prev) => ({
             ...prev,
-            isExecuting: false,
-            error: errorMessage,
-            executionTime
+            is_executing: false,
+            error: error_message,
+            execution_time
           }));
         }
       })();
@@ -472,115 +472,115 @@ function useCommandExecutor(options) {
     []
   );
   useEffect5(() => {
-    if (client && pendingRef.current) {
-      const { statements, params, shapes } = pendingRef.current;
-      command(statements, params, shapes);
+    if (client && pending_ref.current) {
+      const { rql, params, shapes } = pending_ref.current;
+      command(rql, params, shapes);
     }
   }, [client, command]);
-  const cancelCommand = useCallback2(() => {
-    executionIdRef.current++;
+  const cancel_command = useCallback2(() => {
+    execution_id_ref.current++;
     setState((prev) => ({
       ...prev,
-      isExecuting: false,
+      is_executing: false,
       error: "Command cancelled"
     }));
   }, []);
   return {
-    isExecuting: state.isExecuting,
+    is_executing: state.is_executing,
     results: state.results,
     error: state.error,
-    executionTime: state.executionTime,
+    execution_time: state.execution_time,
     command,
-    cancelCommand
+    cancel_command
   };
 }
 
 // src/hooks/use-command.ts
 import { useEffect as useEffect6, useMemo as useMemo2 } from "react";
-function useCommandOne(statement, params, shape, options) {
+function useCommandOne(rql, params, shape, options) {
   const {
-    isExecuting,
+    is_executing,
     results,
     error,
     command
   } = useCommandExecutor(options);
   useEffect6(() => {
     const shapes = shape ? [shape] : void 0;
-    command(statement, params, shapes);
-  }, [statement, params, command]);
+    command(rql, params, shapes);
+  }, [rql, params, command]);
   const result = useMemo2(() => {
     return results && results.length > 0 ? results[0] : void 0;
   }, [results]);
-  return { isExecuting, result, error };
+  return { is_executing, result, error };
 }
-function useCommandMany(statements, params, shapes, options) {
+function useCommandMany(rql, params, shapes, options) {
   const {
-    isExecuting,
+    is_executing,
     results,
     error,
     command
   } = useCommandExecutor(options);
   useEffect6(() => {
-    command(statements, params, shapes);
-  }, [statements, params, command]);
-  return { isExecuting, results, error };
+    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?.connectionConfig);
+  const { client } = useConnection(options?.connection_config);
   const [state, setState] = useState4({
-    isExecuting: false,
+    is_executing: false,
     results: void 0,
     error: void 0,
-    executionTime: void 0
+    execution_time: void 0
   });
-  const clientRef = useRef4(client);
-  clientRef.current = client;
-  const isMountedRef = useRef4(false);
+  const client_ref = useRef4(client);
+  client_ref.current = client;
+  const is_mounted_ref = useRef4(false);
   useEffect7(() => {
-    isMountedRef.current = true;
+    is_mounted_ref.current = true;
     return () => {
-      isMountedRef.current = false;
+      is_mounted_ref.current = false;
     };
   }, []);
-  const executionIdRef = useRef4(0);
-  const pendingRef = useRef4(null);
+  const execution_id_ref = useRef4(0);
+  const pending_ref = useRef4(null);
   const admin = useCallback3(
-    (statements, params, shapes) => {
-      const currentClient = clientRef.current;
-      if (!currentClient) {
-        pendingRef.current = { statements, params, shapes };
-        setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
+    (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();
       }
-      pendingRef.current = null;
-      const thisExecution = ++executionIdRef.current;
-      setState((prev) => ({ ...prev, isExecuting: true, error: void 0 }));
-      const startTime = Date.now();
+      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 frameResults = await currentClient.admin(statements, params || null, shapes || []) || [];
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          const results = frameResults.map((frame) => {
+          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 firstRow = frame[0];
+              const first_row = 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";
+              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: dataType,
+                    type: data_type,
                     payload: []
                   };
                 });
               } else {
-                columns = Object.keys(firstRow).map((key) => ({
+                columns = Object.keys(first_row).map((key) => ({
                   name: key,
                   type: "Utf8",
                   payload: []
@@ -589,42 +589,42 @@ function useAdminExecutor(options) {
               return {
                 columns,
                 rows: frame,
-                executionTimeMs: executionTime
+                execution_time_ms: execution_time
               };
             } else {
               return {
                 columns: [],
                 rows: [],
-                executionTimeMs: executionTime,
-                rowsAffected: typeof frame === "number" ? frame : void 0
+                execution_time_ms: execution_time,
+                rows_affected: typeof frame === "number" ? frame : void 0
               };
             }
           });
-          if (!isMountedRef.current) return;
+          if (!is_mounted_ref.current) return;
           setState({
-            isExecuting: false,
+            is_executing: false,
             results,
             error: void 0,
-            executionTime
+            execution_time
           });
         } catch (err) {
-          if (executionIdRef.current !== thisExecution) return;
-          const executionTime = Date.now() - startTime;
-          let errorMessage = "Admin execution failed";
+          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) {
-            errorMessage = err.message;
+            error_message = err.message;
           } else if (typeof err === "string") {
-            errorMessage = err;
+            error_message = err;
           } else if (err && typeof err === "object" && "message" in err) {
-            errorMessage = err.message;
+            error_message = err.message;
           }
-          console.error("Admin execution failed:", errorMessage);
-          if (!isMountedRef.current) return;
+          console.error("Admin execution failed:", error_message);
+          if (!is_mounted_ref.current) return;
           setState((prev) => ({
             ...prev,
-            isExecuting: false,
-            error: errorMessage,
-            executionTime
+            is_executing: false,
+            error: error_message,
+            execution_time
           }));
         }
       })();
@@ -633,157 +633,157 @@ function useAdminExecutor(options) {
     // stable — never recreates
   );
   useEffect7(() => {
-    if (client && pendingRef.current) {
-      const { statements, params, shapes } = pendingRef.current;
-      admin(statements, params, shapes);
+    if (client && pending_ref.current) {
+      const { rql, params, shapes } = pending_ref.current;
+      admin(rql, params, shapes);
     }
   }, [client, admin]);
-  const cancelAdmin = useCallback3(() => {
-    executionIdRef.current++;
+  const cancel_admin = useCallback3(() => {
+    execution_id_ref.current++;
     setState((prev) => ({
       ...prev,
-      isExecuting: false,
+      is_executing: false,
       error: "Admin cancelled"
     }));
   }, []);
   return {
-    isExecuting: state.isExecuting,
+    is_executing: state.is_executing,
     results: state.results,
     error: state.error,
-    executionTime: state.executionTime,
+    execution_time: state.execution_time,
     admin,
-    cancelAdmin
+    cancel_admin
   };
 }
 
 // src/hooks/use-admin.ts
 import { useEffect as useEffect8, useMemo as useMemo3 } from "react";
-function useAdminOne(statement, params, shape, options) {
+function useAdminOne(rql, params, shape, options) {
   const {
-    isExecuting,
+    is_executing,
     results,
     error,
     admin
   } = useAdminExecutor(options);
   useEffect8(() => {
     const shapes = shape ? [shape] : void 0;
-    admin(statement, params, shapes);
-  }, [statement, params, admin]);
+    admin(rql, params, shapes);
+  }, [rql, params, admin]);
   const result = useMemo3(() => {
     return results && results.length > 0 ? results[0] : void 0;
   }, [results]);
-  return { isExecuting, result, error };
+  return { is_executing, result, error };
 }
-function useAdminMany(statements, params, shapes, options) {
+function useAdminMany(rql, params, shapes, options) {
   const {
-    isExecuting,
+    is_executing,
     results,
     error,
     admin
   } = useAdminExecutor(options);
   useEffect8(() => {
-    admin(statements, params, shapes);
-  }, [statements, params, admin]);
-  return { isExecuting, results, error };
+    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?.connectionConfig);
+  const { client } = useConnection(options?.connection_config);
   const [state, setState] = useState5({
     data: [],
     changes: [],
-    isSubscribed: false,
-    isSubscribing: false,
+    is_subscribed: false,
+    is_subscribing: false,
     error: void 0,
-    subscriptionId: void 0
+    subscription_id: void 0
   });
-  const clientRef = useRef5(client);
+  const client_ref = useRef5(client);
   const subscriptionIdRef = useRef5(void 0);
-  const queryRef = useRef5(void 0);
-  const paramsRef = useRef5(void 0);
-  const shapeRef = useRef5(void 0);
+  const rql_ref = useRef5(void 0);
+  const params_ref = useRef5(void 0);
+  const shape_ref = useRef5(void 0);
   useEffect9(() => {
-    clientRef.current = client;
+    client_ref.current = client;
   }, [client]);
-  const addChangeEvent = useCallback4((operation, rows) => {
+  const add_change_event = useCallback4((operation, rows) => {
     setState((prev) => {
-      const newChange = {
+      const new_change = {
         operation,
         rows,
         timestamp: Date.now()
       };
-      const newChanges = [...prev.changes, newChange];
+      const new_changes = [...prev.changes, new_change];
       return {
         ...prev,
         data: prev.data,
-        changes: newChanges
+        changes: new_changes
       };
     });
   }, []);
-  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 (query, params, shape) => {
-    const currentClient = clientRef.current;
-    if (!currentClient) {
+  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) => {
+    const current_client = client_ref.current;
+    if (!current_client) {
       setState((prev) => ({ ...prev, error: "Client not connected" }));
       return;
     }
-    if (!("subscribe" in currentClient)) {
+    if (!("subscribe" in current_client)) {
       setState((prev) => ({ ...prev, error: "Subscriptions require a WebSocket connection" }));
       return;
     }
-    queryRef.current = query;
-    paramsRef.current = params;
-    shapeRef.current = shape;
+    rql_ref.current = rql;
+    params_ref.current = params;
+    shape_ref.current = shape;
     setState((prev) => ({
       ...prev,
-      isSubscribing: true,
+      is_subscribing: true,
       error: void 0
     }));
     try {
-      const subId = await currentClient.subscribe(query, params, shape, {
-        onInsert: handleInsert,
-        onUpdate: handleUpdate,
-        onRemove: handleRemove
+      const sub_id = await current_client.subscribe(rql, params, shape, {
+        on_insert: handle_insert,
+        on_update: handle_update,
+        on_remove: handle_remove
       });
-      subscriptionIdRef.current = subId;
+      subscriptionIdRef.current = sub_id;
       setState((prev) => ({
         ...prev,
-        isSubscribing: false,
-        isSubscribed: true,
-        subscriptionId: subId
+        is_subscribing: false,
+        is_subscribed: true,
+        subscription_id: sub_id
       }));
     } catch (err) {
       setState((prev) => ({
         ...prev,
-        isSubscribing: false,
+        is_subscribing: false,
         error: err.message || "Subscription failed"
       }));
     }
-  }, [handleInsert, handleUpdate, handleRemove]);
+  }, [handle_insert, handle_update, handle_remove]);
   const unsubscribe = useCallback4(async () => {
-    const currentClient = clientRef.current;
-    if (!currentClient || !subscriptionIdRef.current) return;
-    if (!("unsubscribe" in currentClient)) return;
+    const current_client = client_ref.current;
+    if (!current_client || !subscriptionIdRef.current) return;
+    if (!("unsubscribe" in current_client)) return;
     try {
-      await currentClient.unsubscribe(subscriptionIdRef.current);
+      await current_client.unsubscribe(subscriptionIdRef.current);
       subscriptionIdRef.current = void 0;
-      queryRef.current = void 0;
-      paramsRef.current = void 0;
-      shapeRef.current = void 0;
+      rql_ref.current = void 0;
+      params_ref.current = void 0;
+      shape_ref.current = void 0;
       setState((prev) => ({
         ...prev,
-        isSubscribed: false,
-        subscriptionId: void 0
+        is_subscribed: false,
+        subscription_id: void 0
       }));
     } catch (err) {
       setState((prev) => ({
@@ -792,16 +792,16 @@ function useSubscriptionExecutor(options) {
       }));
     }
   }, []);
-  const clearChanges = useCallback4(() => {
+  const clear_changes = useCallback4(() => {
     setState((prev) => ({ ...prev, changes: [] }));
   }, []);
-  const clearData = useCallback4(() => {
+  const clear_data = useCallback4(() => {
     setState((prev) => ({ ...prev, data: [] }));
   }, []);
   useEffect9(() => {
     return () => {
-      if (subscriptionIdRef.current && clientRef.current && "unsubscribe" in clientRef.current) {
-        clientRef.current.unsubscribe(subscriptionIdRef.current).catch(console.error);
+      if (subscriptionIdRef.current && client_ref.current && "unsubscribe" in client_ref.current) {
+        client_ref.current.unsubscribe(subscriptionIdRef.current).catch(console.error);
       }
     };
   }, []);
@@ -809,56 +809,56 @@ function useSubscriptionExecutor(options) {
     state,
     subscribe,
     unsubscribe,
-    clearChanges,
-    clearData
+    clear_changes,
+    clear_data
   };
 }
 
 // src/hooks/use-subscription.ts
 import { useEffect as useEffect10, useMemo as useMemo4 } from "react";
-function useSubscription(query, params, shape, options) {
+function useSubscription(rql, params, shape, options) {
   const {
     state,
     subscribe,
     unsubscribe
   } = useSubscriptionExecutor(options);
-  const paramsKey = useMemo4(() => JSON.stringify(params), [params]);
+  const params_key = useMemo4(() => JSON.stringify(params), [params]);
   useEffect10(() => {
     if (options?.enabled === false) return;
-    subscribe(query, params, shape);
+    subscribe(rql, params, shape);
     return () => {
       unsubscribe();
     };
-  }, [query, paramsKey, shape, options?.enabled, subscribe, unsubscribe]);
+  }, [rql, params_key, shape, options?.enabled, subscribe, unsubscribe]);
   return {
     data: state.data,
     changes: state.changes,
-    isSubscribed: state.isSubscribed,
-    isSubscribing: state.isSubscribing,
+    is_subscribed: state.is_subscribed,
+    is_subscribing: state.is_subscribing,
     error: state.error,
-    subscriptionId: state.subscriptionId
+    subscription_id: state.subscription_id
   };
 }
 
 // src/hooks/use-shape.ts
 import { useEffect as useEffect11, useState as useState6 } from "react";
 import { Shape } from "@reifydb/core";
-var namespaceShape = Shape.object({
+var namespace_shape = Shape.object({
   id: Shape.number(),
   name: Shape.string()
 });
-var tableShape = Shape.object({
+var table_shape = Shape.object({
   id: Shape.number(),
   namespace_id: Shape.number(),
   name: Shape.string(),
   primary_key_id: Shape.number()
 });
-var viewShape = Shape.object({
+var view_shape = Shape.object({
   id: Shape.number(),
   namespace_id: Shape.number(),
   name: Shape.string()
 });
-var columnShape = Shape.object({
+var column_shape = Shape.object({
   id: Shape.number(),
   shape_id: Shape.number(),
   shape_type: Shape.number(),
@@ -868,78 +868,78 @@ var columnShape = Shape.object({
   auto_increment: Shape.boolean()
 });
 function useShape() {
-  const { isExecuting, results, error, query } = useQueryExecutor();
-  const [shape, setShape] = useState6([]);
-  const [isLoading, setIsLoading] = useState6(true);
+  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 fetchShape = async () => {
-      setIsLoading(true);
+    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,
-          [namespaceShape, tableShape, viewShape, columnShape]
+          [namespace_shape, table_shape, view_shape, column_shape]
         );
       } catch (err) {
         console.error("Failed to fetch shape:", err);
       }
     };
-    fetchShape();
+    fetch_shape();
   }, [query]);
   useEffect11(() => {
     if (!results || results.length < 4) {
-      setIsLoading(isExecuting);
+      set_is_loading(is_executing);
       return;
     }
-    const tablesResult = results[1];
-    const viewsResult = results[2];
-    const columnsResult = results[3];
-    if (!tablesResult?.rows || !viewsResult?.rows || !columnsResult?.rows) {
-      setIsLoading(false);
+    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 namespacesResult = results[0];
-    const namespaces = namespacesResult.rows;
-    const tables = tablesResult.rows;
-    const views = viewsResult.rows;
-    const columns = columnsResult.rows;
-    const namespaceMap = /* @__PURE__ */ new Map();
+    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 = ns.id?.valueOf();
       const name = ns.name?.valueOf();
       if (id !== void 0 && name) {
-        namespaceMap.set(id, name);
+        namespace_map.set(id, name);
       }
     });
-    const tableInfoMap = /* @__PURE__ */ new Map();
+    const table_info_map = /* @__PURE__ */ new Map();
     tables.forEach((table) => {
-      const tableId = table.id?.valueOf();
-      const namespaceId = table.namespace_id?.valueOf();
-      const tableName = table.name?.valueOf();
-      if (tableId === void 0 || !tableName || namespaceId === void 0) return;
-      const namespace = namespaceMap.get(namespaceId);
+      const table_id = table.id?.valueOf();
+      const namespace_id = table.namespace_id?.valueOf();
+      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 fullTableName = `${namespace}::${tableName}`;
-      tableInfoMap.set(tableId, {
-        name: fullTableName,
+      const full_table_name = `${namespace}::${table_name}`;
+      table_info_map.set(table_id, {
+        name: full_table_name,
         columns: []
       });
     });
     views.forEach((view) => {
-      const viewId = view.id?.valueOf();
-      const namespaceId = view.namespace_id?.valueOf();
-      const viewName = view.name?.valueOf();
-      if (viewId === void 0 || !viewName || namespaceId === void 0) return;
-      const namespace = namespaceMap.get(namespaceId);
+      const view_id = view.id?.valueOf();
+      const namespace_id = view.namespace_id?.valueOf();
+      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 fullViewName = `${namespace}::${viewName}`;
-      tableInfoMap.set(viewId, {
-        name: fullViewName,
+      const full_view_name = `${namespace}::${view_name}`;
+      table_info_map.set(view_id, {
+        name: full_view_name,
         columns: []
       });
     });
-    const typeMap = {
+    const type_map = {
       0: "None",
       1: "Float4",
       2: "Float8",
@@ -968,36 +968,36 @@ function useShape() {
       25: "Uint",
       26: "Any"
     };
-    const tableColumnsMap = /* @__PURE__ */ new Map();
+    const table_columns_map = /* @__PURE__ */ new Map();
     columns.forEach((column) => {
-      const shapeId = column.shape_id?.valueOf();
-      const shapeType = column.shape_type?.valueOf();
-      const columnName = column.name?.valueOf();
-      const typeId = column.type?.valueOf();
+      const shape_id = column.shape_id?.valueOf();
+      const shape_type = column.shape_type?.valueOf();
+      const column_name = column.name?.valueOf();
+      const type_id = column.type?.valueOf();
       const position = column.position?.valueOf();
-      if (shapeId === void 0 || !columnName || typeId === void 0) return;
-      if (shapeType !== 0 && shapeType !== 1) return;
-      if (!tableColumnsMap.has(shapeId)) {
-        tableColumnsMap.set(shapeId, []);
+      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, []);
       }
-      tableColumnsMap.get(shapeId).push({
-        name: columnName,
-        dataType: typeMap[typeId] || `Unknown(${typeId})`,
+      table_columns_map.get(shape_id).push({
+        name: column_name,
+        data_type: type_map[type_id] || `Unknown(${type_id})`,
         position: position ?? 0
       });
     });
-    tableColumnsMap.forEach((cols, shapeId) => {
-      const tableInfo = tableInfoMap.get(shapeId);
-      if (tableInfo) {
+    table_columns_map.forEach((cols, shape_id) => {
+      const table_info = table_info_map.get(shape_id);
+      if (table_info) {
         cols.sort((a, b) => a.position - b.position);
-        tableInfo.columns = cols.map((c) => ({ name: c.name, dataType: c.dataType }));
+        table_info.columns = cols.map((c) => ({ name: c.name, data_type: c.data_type }));
       }
     });
-    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];
+    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];
 }
 export {
   Connection,
@@ -1005,8 +1005,8 @@ export {
   ConnectionProvider,
   DEFAULT_CONFIG,
   DEFAULT_URL,
-  clearConnection,
-  getConnection,
+  clear_connection,
+  get_connection,
   useAdminExecutor,
   useAdminMany,
   useAdminOne,