@reifydb/client 0.4.1 → 0.4.6

package/dist/index.js

@@ -143,7 +143,9 @@ var WsClient = class _WsClient {
         socket.addEventListener("error", onError);
       });
     }
-    socket.send('{"id":"auth-1","type":"Auth","payload":{"token":"mysecrettoken"}}');
+    if (options.token) {
+      socket.send(JSON.stringify({ id: "auth-1", type: "Auth", payload: { token: options.token } }));
+    }
     return new _WsClient(socket, options);
   }
   /**
@@ -384,6 +386,71 @@ var WsClient = class _WsClient {
     }
     return value;
   }
+  async loginWithPassword(principal, password) {
+    return this.login("password", principal, { password });
+  }
+  async loginWithToken(principal, token) {
+    return this.login("token", principal, { token });
+  }
+  async login(method, principal, credentials) {
+    const id = `auth-${this.nextId++}`;
+    const request = {
+      id,
+      type: "Auth",
+      payload: { method, principal, credentials }
+    };
+    const response = await new Promise((resolve, reject) => {
+      const timeoutMs = this.options.timeoutMs ?? 3e4;
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("Login timeout"));
+      }, timeoutMs);
+      this.pending.set(id, (res) => {
+        clearTimeout(timeout);
+        resolve(res);
+      });
+      this.socket.send(JSON.stringify(request));
+    });
+    if (response.type === "Err") {
+      throw new ReifyError(response);
+    }
+    if (response.type !== "Auth") {
+      throw new Error(`Unexpected response type: ${response.type}`);
+    }
+    const payload = response.payload;
+    if (payload.status !== "authenticated" || !payload.token || !payload.identity) {
+      throw new Error("Authentication failed");
+    }
+    this.options.token = payload.token;
+    return { token: payload.token, identity: payload.identity };
+  }
+  async logout() {
+    if (!this.options.token) {
+      return;
+    }
+    const id = `logout-${this.nextId++}`;
+    const request = {
+      id,
+      type: "Logout",
+      payload: {}
+    };
+    const response = await new Promise((resolve, reject) => {
+      const timeoutMs = this.options.timeoutMs ?? 3e4;
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("Logout timeout"));
+      }, timeoutMs);
+      this.pending.set(id, (res) => {
+        clearTimeout(timeout);
+        resolve(res);
+      });
+      this.socket.send(JSON.stringify(request));
+    });
+    if (response.type === "Err") {
+      throw new ReifyError(response);
+    }
+    this.options = { ...this.options, token: void 0 };
+  }
   disconnect() {
     this.shouldReconnect = false;
     this.subscriptions.clear();
@@ -435,7 +502,9 @@ var WsClient = class _WsClient {
           socket.addEventListener("error", onError);
         });
       }
-      socket.send('{"id":"auth-1","type":"Auth","payload":{"token":"mysecrettoken"}}');
+      if (this.options.token) {
+        socket.send(JSON.stringify({ id: "auth-1", type: "Auth", payload: { token: this.options.token } }));
+      }
       this.socket = socket;
       this.setupSocketHandlers();
       this.reconnectAttempts = 0;
@@ -468,14 +537,14 @@ var WsClient = class _WsClient {
     if (frames.length === 0) return;
     const frame = frames[0];
     const opColumn = frame.columns.find((c) => c.name === "_op");
-    if (!opColumn || opColumn.data.length === 0) {
+    if (!opColumn || opColumn.payload.length === 0) {
       console.error("Missing or empty _op column:", { opColumn, frame });
       return;
     }
     const rows = this.frameToRows(frame, state.schema);
     const batches = [];
     for (let i = 0; i < rows.length; i++) {
-      const opValue = parseInt(opColumn.data[i]);
+      const opValue = parseInt(opColumn.payload[i]);
       const operation = opValue === 1 ? "INSERT" : opValue === 2 ? "UPDATE" : opValue === 3 ? "REMOVE" : "INSERT";
       const { _op, ...cleanRow } = rows[i];
       if (batches.length > 0 && batches[batches.length - 1].op === operation) {
@@ -500,12 +569,12 @@ var WsClient = class _WsClient {
   }
   frameToRows(frame, schema) {
     if (!frame.columns || frame.columns.length === 0) return [];
-    const rowCount = frame.columns[0].data.length;
+    const rowCount = frame.columns[0].payload.length;
     const rows = [];
     for (let i = 0; i < rowCount; i++) {
       const row = {};
       for (const col of frame.columns) {
-        row[col.name] = decode({ type: col.type, value: col.data[i] });
+        row[col.name] = decode({ type: col.type, value: col.payload[i] });
       }
       rows.push(row);
     }
@@ -557,17 +626,390 @@ var WsClient = class _WsClient {
   }
 };
 function columnsToRows(columns) {
-  const rowCount = columns[0]?.data.length ?? 0;
+  const rowCount = columns[0]?.payload.length ?? 0;
   return Array.from({ length: rowCount }, (_, i) => {
     const row = {};
     for (const col of columns) {
-      row[col.name] = decode({ type: col.type, value: col.data[i] });
+      row[col.name] = decode({ type: col.type, value: col.payload[i] });
     }
     return row;
   });
 }
 
-// src/json.ts
+// src/http.ts
+import {
+  decode as decode2
+} from "@reifydb/core";
+var HttpClient = class _HttpClient {
+  constructor(options) {
+    this.options = options;
+  }
+  static connect(options) {
+    return new _HttpClient(options);
+  }
+  async loginWithPassword(principal, password) {
+    return this.login("password", principal, { password });
+  }
+  async loginWithToken(principal, token) {
+    return this.login("token", principal, { token });
+  }
+  async login(method, principal, credentials) {
+    const timeoutMs = this.options.timeoutMs ?? 3e4;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${this.options.url}/v1/authenticate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ method, principal, credentials }),
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      const body = await response.json();
+      if (body.status !== "authenticated" || !body.token || !body.identity) {
+        throw new Error(body.reason || "Authentication failed");
+      }
+      this.options = { ...this.options, token: body.token };
+      return { token: body.token, identity: body.identity };
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") throw new Error("Login timeout");
+      throw err;
+    }
+  }
+  async logout() {
+    if (!this.options.token) {
+      return;
+    }
+    const timeoutMs = this.options.timeoutMs ?? 3e4;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${this.options.url}/v1/logout`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.options.token}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Logout failed: HTTP ${response.status}: ${body}`);
+      }
+      this.options = { ...this.options, token: void 0 };
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") throw new Error("Logout timeout");
+      throw err;
+    }
+  }
+  async admin(statements, params, schemas) {
+    const statementArray = Array.isArray(statements) ? statements : [statements];
+    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
+    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    const result = await this.send("admin", outputStatements, encodedParams);
+    const transformedFrames = result.map((frame, frameIndex) => {
+      const frameSchema = schemas[frameIndex];
+      if (!frameSchema) {
+        return frame;
+      }
+      return frame.map((row) => this.transformResult(row, frameSchema));
+    });
+    return transformedFrames;
+  }
+  async command(statements, params, schemas) {
+    const statementArray = Array.isArray(statements) ? statements : [statements];
+    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
+    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    const result = await this.send("command", outputStatements, encodedParams);
+    const transformedFrames = result.map((frame, frameIndex) => {
+      const frameSchema = schemas[frameIndex];
+      if (!frameSchema) {
+        return frame;
+      }
+      return frame.map((row) => this.transformResult(row, frameSchema));
+    });
+    return transformedFrames;
+  }
+  async query(statements, params, schemas) {
+    const statementArray = Array.isArray(statements) ? statements : [statements];
+    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
+    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    const result = await this.send("query", outputStatements, encodedParams);
+    const transformedFrames = result.map((frame, frameIndex) => {
+      const frameSchema = schemas[frameIndex];
+      if (!frameSchema) {
+        return frame;
+      }
+      return frame.map((row) => this.transformResult(row, frameSchema));
+    });
+    return transformedFrames;
+  }
+  async send(endpoint, statements, params) {
+    const timeoutMs = this.options.timeoutMs ?? 3e4;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.options.token) {
+      headers["Authorization"] = `Bearer ${this.options.token}`;
+    }
+    const body = { statements };
+    if (params !== void 0) {
+      body.params = params;
+    }
+    try {
+      const response = await fetch(`${this.options.url}/v1/${endpoint}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal,
+        credentials: "include"
+      });
+      clearTimeout(timeout);
+      const responseBody = await response.text();
+      let parsed;
+      try {
+        parsed = JSON.parse(responseBody);
+      } catch {
+        throw new Error(`Invalid JSON response: ${responseBody}`);
+      }
+      if (!response.ok) {
+        if (parsed.diagnostic) {
+          throw new ReifyError({
+            id: "",
+            type: "Err",
+            payload: { diagnostic: parsed.diagnostic }
+          });
+        }
+        throw new Error(parsed.error || `HTTP ${response.status}: ${responseBody}`);
+      }
+      const frames = parsed.frames || [];
+      return frames.map(
+        (frame) => columnsToRows2(frame.columns)
+      );
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") {
+        throw new Error("ReifyDB query timeout");
+      }
+      throw err;
+    }
+  }
+  transformResult(row, resultSchema) {
+    if (resultSchema && resultSchema.kind === "object" && resultSchema.properties) {
+      const transformedRow = {};
+      for (const [key, value] of Object.entries(row)) {
+        const propertySchema = resultSchema.properties[key];
+        if (propertySchema && propertySchema.kind === "primitive") {
+          if (value && typeof value === "object" && typeof value.valueOf === "function") {
+            const rawValue = value.valueOf();
+            transformedRow[key] = this.coerceToPrimitiveType(rawValue, propertySchema.type);
+          } else {
+            transformedRow[key] = this.coerceToPrimitiveType(value, propertySchema.type);
+          }
+        } else if (propertySchema && propertySchema.kind === "value") {
+          transformedRow[key] = value;
+        } else {
+          transformedRow[key] = propertySchema ? this.transformResult(value, propertySchema) : value;
+        }
+      }
+      return transformedRow;
+    }
+    if (resultSchema && resultSchema.kind === "primitive") {
+      if (row && typeof row === "object" && typeof row.valueOf === "function") {
+        return this.coerceToPrimitiveType(row.valueOf(), resultSchema.type);
+      }
+      return this.coerceToPrimitiveType(row, resultSchema.type);
+    }
+    if (resultSchema && resultSchema.kind === "value") {
+      return row;
+    }
+    if (resultSchema && resultSchema.kind === "array") {
+      if (Array.isArray(row)) {
+        return row.map((item) => this.transformResult(item, resultSchema.items));
+      }
+      return row;
+    }
+    if (resultSchema && resultSchema.kind === "optional") {
+      if (row === void 0 || row === null) {
+        return void 0;
+      }
+      return this.transformResult(row, resultSchema.schema);
+    }
+    return row;
+  }
+  coerceToPrimitiveType(value, schemaType) {
+    if (value === void 0 || value === null) {
+      return value;
+    }
+    const bigintTypes = ["Int8", "Int16", "Uint8", "Uint16"];
+    if (bigintTypes.includes(schemaType)) {
+      if (typeof value === "bigint") {
+        return value;
+      }
+      if (typeof value === "number") {
+        return BigInt(Math.trunc(value));
+      }
+      if (typeof value === "string") {
+        return BigInt(value);
+      }
+    }
+    return value;
+  }
+};
+function columnsToRows2(columns) {
+  const rowCount = columns[0]?.payload.length ?? 0;
+  return Array.from({ length: rowCount }, (_, i) => {
+    const row = {};
+    for (const col of columns) {
+      row[col.name] = decode2({ type: col.type, value: col.payload[i] });
+    }
+    return row;
+  });
+}
+
+// src/json-http.ts
+var JsonHttpClient = class _JsonHttpClient {
+  constructor(options) {
+    this.options = options;
+  }
+  static connect(options) {
+    return new _JsonHttpClient(options);
+  }
+  async loginWithPassword(principal, password) {
+    return this.login("password", principal, { password });
+  }
+  async loginWithToken(principal, token) {
+    return this.login("token", principal, { token });
+  }
+  async login(method, principal, credentials) {
+    const timeoutMs = this.options.timeoutMs ?? 3e4;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${this.options.url}/v1/authenticate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ method, principal, credentials }),
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      const body = await response.json();
+      if (body.status !== "authenticated" || !body.token || !body.identity) {
+        throw new Error(body.reason || "Authentication failed");
+      }
+      this.options = { ...this.options, token: body.token };
+      return { token: body.token, identity: body.identity };
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") throw new Error("Login timeout");
+      throw err;
+    }
+  }
+  async logout() {
+    if (!this.options.token) {
+      return;
+    }
+    const timeoutMs = this.options.timeoutMs ?? 3e4;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(`${this.options.url}/v1/logout`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.options.token}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Logout failed: HTTP ${response.status}: ${body}`);
+      }
+      this.options = { ...this.options, token: void 0 };
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") throw new Error("Logout timeout");
+      throw err;
+    }
+  }
+  async admin(statements, params) {
+    const statementArray = Array.isArray(statements) ? statements : [statements];
+    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
+    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    return this.send("admin", outputStatements, encodedParams);
+  }
+  async command(statements, params) {
+    const statementArray = Array.isArray(statements) ? statements : [statements];
+    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
+    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    return this.send("command", outputStatements, encodedParams);
+  }
+  async query(statements, params) {
+    const statementArray = Array.isArray(statements) ? statements : [statements];
+    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
+    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    return this.send("query", outputStatements, encodedParams);
+  }
+  async send(endpoint, statements, params) {
+    const timeoutMs = this.options.timeoutMs ?? 3e4;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.options.token) {
+      headers["Authorization"] = `Bearer ${this.options.token}`;
+    }
+    const body = { statements };
+    if (params !== void 0) {
+      body.params = params;
+    }
+    const queryParams = new URLSearchParams({ format: "json" });
+    if (this.options.unwrap) {
+      queryParams.set("unwrap", "true");
+    }
+    try {
+      const response = await fetch(`${this.options.url}/v1/${endpoint}?${queryParams}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal,
+        credentials: "include"
+      });
+      clearTimeout(timeout);
+      const responseBody = await response.text();
+      let parsed;
+      try {
+        parsed = JSON.parse(responseBody);
+      } catch {
+        throw new Error(`Invalid JSON response: ${responseBody}`);
+      }
+      if (!response.ok) {
+        if (parsed.diagnostic) {
+          throw new ReifyError({
+            id: "",
+            type: "Err",
+            payload: { diagnostic: parsed.diagnostic }
+          });
+        }
+        throw new Error(parsed.error || `HTTP ${response.status}: ${responseBody}`);
+      }
+      return parsed;
+    } catch (err) {
+      clearTimeout(timeout);
+      if (err.name === "AbortError") {
+        throw new Error("ReifyDB query timeout");
+      }
+      throw err;
+    }
+  }
+};
+
+// src/json-ws.ts
 async function createWebSocket2(url) {
   if (typeof window !== "undefined" && typeof window.WebSocket !== "undefined") {
     return new WebSocket(url);
@@ -576,7 +1018,7 @@ async function createWebSocket2(url) {
     return new wsModule.WebSocket(url);
   }
 }
-var JsonWsClient = class _JsonWsClient {
+var JsonWebsocketClient = class _JsonWebsocketClient {
   constructor(socket, options) {
     this.pending = /* @__PURE__ */ new Map();
     this.reconnectAttempts = 0;
@@ -614,27 +1056,61 @@ var JsonWsClient = class _JsonWsClient {
         socket.addEventListener("error", onError);
       });
     }
-    socket.send('{"id":"auth-1","type":"Auth","payload":{"token":"mysecrettoken"}}');
-    return new _JsonWsClient(socket, options);
-  }
-  async query(statements, params) {
-    return this.send("Query", statements, params);
-  }
-  async command(statements, params) {
-    return this.send("Command", statements, params);
+    if (options.token) {
+      socket.send(JSON.stringify({ id: "auth-1", type: "Auth", payload: { token: options.token } }));
+    }
+    return new _JsonWebsocketClient(socket, options);
   }
   async admin(statements, params) {
-    return this.send("Admin", statements, params);
+    const id = `req-${this.nextId++}`;
+    const statementArray = Array.isArray(statements) ? statements : [statements];
+    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
+    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    return this.send({
+      id,
+      type: "Admin",
+      payload: {
+        statements: outputStatements,
+        params: encodedParams,
+        format: "json",
+        ...this.options.unwrap ? { unwrap: true } : {}
+      }
+    });
   }
-  disconnect() {
-    this.shouldReconnect = false;
-    this.socket.close();
+  async command(statements, params) {
+    const id = `req-${this.nextId++}`;
+    const statementArray = Array.isArray(statements) ? statements : [statements];
+    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
+    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    return this.send({
+      id,
+      type: "Command",
+      payload: {
+        statements: outputStatements,
+        params: encodedParams,
+        format: "json",
+        ...this.options.unwrap ? { unwrap: true } : {}
+      }
+    });
   }
-  async send(type, statements, params) {
+  async query(statements, params) {
     const id = `req-${this.nextId++}`;
     const statementArray = Array.isArray(statements) ? statements : [statements];
     const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
     const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
+    return this.send({
+      id,
+      type: "Query",
+      payload: {
+        statements: outputStatements,
+        params: encodedParams,
+        format: "json",
+        ...this.options.unwrap ? { unwrap: true } : {}
+      }
+    });
+  }
+  async send(req) {
+    const id = req.id;
     if (this.socket.readyState !== 1) {
       throw new ReifyError({
         id: "connection-error",
@@ -658,33 +1134,84 @@ var JsonWsClient = class _JsonWsClient {
         clearTimeout(timeout);
         resolve(res);
       });
-      this.socket.send(JSON.stringify({
-        id,
-        type,
-        payload: {
-          statements: outputStatements,
-          params: encodedParams,
-          format: "json"
-        }
-      }));
+      this.socket.send(JSON.stringify(req));
     });
     if (response.type === "Err") {
       throw new ReifyError(response);
     }
-    if (response.type !== type) {
+    if (response.type !== req.type) {
       throw new Error(`Unexpected response type: ${response.type}`);
     }
-    const body = response.payload.body;
-    if (Array.isArray(body) && body.length > 0 && Array.isArray(body[0])) {
-      return body;
+    return response.payload.body;
+  }
+  async loginWithPassword(principal, password) {
+    return this.login("password", principal, { password });
+  }
+  async loginWithToken(principal, token) {
+    return this.login("token", principal, { token });
+  }
+  async login(method, principal, credentials) {
+    const id = `auth-${this.nextId++}`;
+    const request = {
+      id,
+      type: "Auth",
+      payload: { method, principal, credentials }
+    };
+    const response = await new Promise((resolve, reject) => {
+      const timeoutMs = this.options.timeoutMs ?? 3e4;
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("Login timeout"));
+      }, timeoutMs);
+      this.pending.set(id, (res) => {
+        clearTimeout(timeout);
+        resolve(res);
+      });
+      this.socket.send(JSON.stringify(request));
+    });
+    if (response.type === "Err") {
+      throw new ReifyError(response);
+    }
+    if (response.type !== "Auth") {
+      throw new Error(`Unexpected response type: ${response.type}`);
     }
-    if (Array.isArray(body)) {
-      return [body];
+    const payload = response.payload;
+    if (payload.status !== "authenticated" || !payload.token || !payload.identity) {
+      throw new Error("Authentication failed");
     }
-    if (body && typeof body === "object") {
-      return [[body]];
+    this.options.token = payload.token;
+    return { token: payload.token, identity: payload.identity };
+  }
+  async logout() {
+    if (!this.options.token) {
+      return;
     }
-    return [];
+    const id = `logout-${this.nextId++}`;
+    const request = {
+      id,
+      type: "Logout",
+      payload: {}
+    };
+    const response = await new Promise((resolve, reject) => {
+      const timeoutMs = this.options.timeoutMs ?? 3e4;
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("Logout timeout"));
+      }, timeoutMs);
+      this.pending.set(id, (res) => {
+        clearTimeout(timeout);
+        resolve(res);
+      });
+      this.socket.send(JSON.stringify(request));
+    });
+    if (response.type === "Err") {
+      throw new ReifyError(response);
+    }
+    this.options = { ...this.options, token: void 0 };
+  }
+  disconnect() {
+    this.shouldReconnect = false;
+    this.socket.close();
   }
   handleDisconnect() {
     this.rejectAllPendingRequests();
@@ -693,6 +1220,7 @@ var JsonWsClient = class _JsonWsClient {
     }
     const maxAttempts = this.options.maxReconnectAttempts ?? 5;
     if (this.reconnectAttempts >= maxAttempts) {
+      console.error(`Max reconnection attempts (${maxAttempts}) reached`);
       return;
     }
     this.attemptReconnect();
@@ -702,6 +1230,7 @@ var JsonWsClient = class _JsonWsClient {
     this.reconnectAttempts++;
     const baseDelay = this.options.reconnectDelayMs ?? 1e3;
     const delay = baseDelay * Math.pow(2, this.reconnectAttempts - 1);
+    console.log(`Attempting reconnection in ${delay}ms`);
     await new Promise((resolve) => setTimeout(resolve, delay));
     try {
       const socket = await createWebSocket2(this.options.url);
@@ -730,7 +1259,9 @@ var JsonWsClient = class _JsonWsClient {
           socket.addEventListener("error", onError);
         });
       }
-      socket.send('{"id":"auth-1","type":"Auth","payload":{"token":"mysecrettoken"}}');
+      if (this.options.token) {
+        socket.send(JSON.stringify({ id: "auth-1", type: "Auth", payload: { token: this.options.token } }));
+      }
       this.socket = socket;
       this.setupSocketHandlers();
       this.reconnectAttempts = 0;
@@ -746,15 +1277,16 @@ var JsonWsClient = class _JsonWsClient {
       if (!msg.id) {
         return;
       }
-      const { id } = msg;
+      const { id, type, payload } = msg;
       const handler = this.pending.get(id);
       if (!handler) {
         return;
       }
       this.pending.delete(id);
-      handler(msg);
+      handler({ id, type, payload });
     };
-    this.socket.onerror = () => {
+    this.socket.onerror = (err) => {
+      console.error("WebSocket error", err);
     };
     this.socket.onclose = () => {
       this.handleDisconnect();
@@ -779,95 +1311,6 @@ var JsonWsClient = class _JsonWsClient {
   }
 };
 
-// src/http.ts
-var JsonHttpClient = class _JsonHttpClient {
-  constructor(options) {
-    this.options = options;
-  }
-  static connect(options) {
-    return new _JsonHttpClient(options);
-  }
-  async query(statements, params) {
-    return this.send("query", statements, params);
-  }
-  async command(statements, params) {
-    return this.send("command", statements, params);
-  }
-  async admin(statements, params) {
-    return this.send("admin", statements, params);
-  }
-  async send(endpoint, statements, params) {
-    const statementArray = Array.isArray(statements) ? statements : [statements];
-    const outputStatements = statementArray.length > 1 ? statementArray.map((s) => s.trim() ? `OUTPUT ${s}` : s) : statementArray;
-    const encodedParams = params !== void 0 && params !== null ? encodeParams(params) : void 0;
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.options.token) {
-      headers["Authorization"] = `Bearer ${this.options.token}`;
-    } else if (this.options.apiKey) {
-      headers["X-Api-Key"] = this.options.apiKey;
-    }
-    const baseUrl = this.options.url.replace(/\/+$/, "");
-    const timeoutMs = this.options.timeoutMs ?? 3e4;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    let response;
-    try {
-      response = await fetch(`${baseUrl}/v1/${endpoint}?format=json`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          statements: outputStatements,
-          params: encodedParams
-        }),
-        signal: controller.signal
-      });
-    } catch (err) {
-      if (err.name === "AbortError") {
-        throw new Error("ReifyDB query timeout");
-      }
-      throw err;
-    } finally {
-      clearTimeout(timeout);
-    }
-    const body = await response.json();
-    if (!response.ok) {
-      if (body.diagnostic) {
-        throw new ReifyError({
-          id: "",
-          type: "Err",
-          payload: { diagnostic: body.diagnostic }
-        });
-      }
-      if (body.error) {
-        throw new ReifyError({
-          id: "",
-          type: "Err",
-          payload: {
-            diagnostic: {
-              code: body.code ?? "HTTP_ERROR",
-              message: body.error,
-              notes: []
-            }
-          }
-        });
-      }
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-    if (Array.isArray(body) && body.length > 0 && Array.isArray(body[0])) {
-      return body;
-    }
-    if (Array.isArray(body)) {
-      return [body];
-    }
-    if (body && typeof body === "object") {
-      return [[body]];
-    }
-    return [];
-  }
-};
-
 // src/index.ts
 import { ReifyError as ReifyError2, asFrameResults } from "@reifydb/core";
 var Client = class {
@@ -881,28 +1324,38 @@ var Client = class {
     return WsClient.connect({ url, ...options });
   }
   /**
-   * Connect to ReifyDB via WebSocket with JSON format responses
-   * @param url WebSocket URL
+   * Connect to ReifyDB via HTTP
+   * @param url HTTP URL
    * @param options Optional configuration
-   * @returns Connected JSON WebSocket client
+   * @returns HTTP client (sync, no connection to await)
    */
-  static async connect_json_ws(url, options = {}) {
-    return JsonWsClient.connect({ url, ...options });
+  static connect_http(url, options = {}) {
+    return HttpClient.connect({ url, ...options });
   }
   /**
-   * Connect to ReifyDB via HTTP with JSON format responses
-   * @param url Base HTTP URL
+   * Connect to ReifyDB via HTTP with JSON response format
+   * @param url HTTP URL
    * @param options Optional configuration
-   * @returns JSON HTTP client
+   * @returns JSON HTTP client (sync, no connection to await)
    */
   static connect_json_http(url, options = {}) {
     return JsonHttpClient.connect({ url, ...options });
   }
+  /**
+   * Connect to ReifyDB via WebSocket with JSON response format
+   * @param url WebSocket URL
+   * @param options Optional configuration
+   * @returns Connected JSON WebSocket client
+   */
+  static async connect_json_ws(url, options = {}) {
+    return JsonWebsocketClient.connect({ url, ...options });
+  }
 };
 export {
   Client,
+  HttpClient,
   JsonHttpClient,
-  JsonWsClient,
+  JsonWebsocketClient,
   ReifyError2 as ReifyError,
   WsClient,
   asFrameResults