hyperdb-wasm 0.0.26268-dev.remotes-origin-wasm.gcf8d815a

package/dist/node.js

@@ -0,0 +1,532 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// protocol.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function hasKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function isWasmResult(value) {
+  if (!isRecord(value) || typeof value.state !== "string") return false;
+  switch (value.state) {
+    case "ok":
+    case "chunk":
+      return hasKeys(value, ["state", "payload"]) && value.payload instanceof Uint8Array;
+    case "pending":
+    case "done":
+      return hasKeys(value, ["state"]);
+    case "error":
+    case "busy":
+      return hasKeys(value, ["state", "error"]) && typeof value.error === "string";
+    default:
+      return false;
+  }
+}
+function isWorkerEvent(message) {
+  if (!isRecord(message) || typeof message.type !== "string") return false;
+  switch (message.type) {
+    case "ready":
+      return hasKeys(message, ["type"]);
+    case "fatal":
+      return hasKeys(message, ["type", "error"]) && typeof message.error === "string";
+    case "log":
+      return hasKeys(message, ["type", "text"]) && typeof message.text === "string";
+    case "response":
+      return hasKeys(message, ["id", "type", "result"]) && Number.isSafeInteger(message.id) && isWasmResult(message.result);
+    default:
+      return false;
+  }
+}
+var init_protocol = __esm({
+  "protocol.ts"() {
+    "use strict";
+  }
+});
+
+// client.ts
+var HyperDBEngineClient;
+var init_client = __esm({
+  "client.ts"() {
+    "use strict";
+    init_protocol();
+    HyperDBEngineClient = class {
+      transport;
+      pending = /* @__PURE__ */ new Map();
+      readyPromise;
+      resolveReady;
+      rejectReady;
+      nextId = 1;
+      failed;
+      unsubscribe;
+      constructor(transport) {
+        this.transport = transport;
+        this.readyPromise = new Promise((resolve, reject) => {
+          this.resolveReady = resolve;
+          this.rejectReady = reject;
+        });
+        this.unsubscribe = [
+          transport.onMessage((message) => this.onMessage(message)),
+          transport.onError((error) => this.fail(error)),
+          transport.onClose((error) => this.fail(error))
+        ];
+      }
+      ready() {
+        return this.readyPromise;
+      }
+      connect() {
+        return this.request({ id: this.nextId++, type: "connect" });
+      }
+      disconnect(connection) {
+        return this.request({ id: this.nextId++, type: "disconnect", connection });
+      }
+      startQuery(connection, sql) {
+        return this.request({ id: this.nextId++, type: "startQuery", connection, sql });
+      }
+      insertArrowIPCFromPath(connection, path, name, schema, create, internal = false) {
+        return this.request({ id: this.nextId++, type: "insertArrowIPCFromPath", connection, path, name, schema, create, internal });
+      }
+      createTemporaryFile(bytes) {
+        const payload = bytes.slice();
+        return this.request({ id: this.nextId++, type: "createTemporaryFile", bytes: payload }, [payload.buffer]);
+      }
+      removeFile(path) {
+        return this.request({ id: this.nextId++, type: "removeFile", path });
+      }
+      pollQuery(query) {
+        return this.request({ id: this.nextId++, type: "pollQuery", query });
+      }
+      cancelQuery(query) {
+        return this.request({ id: this.nextId++, type: "cancelQuery", query });
+      }
+      releaseQuery(query) {
+        return this.request({ id: this.nextId++, type: "releaseQuery", query });
+      }
+      async terminate() {
+        this.fail(new Error("engine worker terminated"));
+        await this.transport.terminate();
+      }
+      request(request, transfer = []) {
+        if (this.failed) return Promise.reject(this.failed);
+        return new Promise((resolve, reject) => {
+          this.pending.set(request.id, { resolve, reject });
+          try {
+            this.transport.postMessage(request, transfer);
+          } catch (error) {
+            this.pending.delete(request.id);
+            reject(error instanceof Error ? error : new Error(String(error)));
+          }
+        });
+      }
+      onMessage(message) {
+        if (!isWorkerEvent(message)) return;
+        if (message.type === "ready") {
+          this.resolveReady();
+          return;
+        }
+        if (message.type === "fatal") {
+          this.fail(new Error(message.error || "engine aborted"));
+          return;
+        }
+        if (message.type !== "response") return;
+        const pending = this.pending.get(message.id);
+        if (!pending) return;
+        this.pending.delete(message.id);
+        pending.resolve(message.result);
+      }
+      fail(error) {
+        if (this.failed) return;
+        this.failed = error;
+        for (const unsubscribe of this.unsubscribe.splice(0)) unsubscribe();
+        this.rejectReady(error);
+        for (const pending of this.pending.values()) pending.reject(error);
+        this.pending.clear();
+      }
+    };
+  }
+});
+
+// browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  BrowserWorker: () => BrowserWorker,
+  createBrowserClient: () => createBrowserClient,
+  resolveBrowserWorkerUrl: () => resolveBrowserWorkerUrl
+});
+function resolveBrowserWorkerUrl(workerUrl, engineUrl) {
+  const resolved = new URL(workerUrl);
+  resolved.searchParams.set("engineUrl", new URL(engineUrl).href);
+  return resolved;
+}
+function createBrowserClient(options = {}) {
+  const workerUrl = options.workerUrl ?? new URL("./browser_worker.js", import.meta.url);
+  const engineUrl = options.engineUrl ?? new URL("./hyperdb-wasm.js", import.meta.url);
+  return new HyperDBEngineClient(new BrowserWorker(new Worker(resolveBrowserWorkerUrl(workerUrl, engineUrl), { type: "classic" })));
+}
+var BrowserWorker;
+var init_browser = __esm({
+  "browser.ts"() {
+    "use strict";
+    init_client();
+    BrowserWorker = class {
+      constructor(worker) {
+        this.worker = worker;
+      }
+      worker;
+      postMessage(message, transfer = []) {
+        this.worker.postMessage(message, [...transfer]);
+      }
+      onMessage(listener) {
+        const wrapped = (event) => listener(event.data);
+        this.worker.addEventListener("message", wrapped);
+        return () => this.worker.removeEventListener("message", wrapped);
+      }
+      onError(listener) {
+        const wrapped = (event) => listener(new Error(event.message || "engine worker error"));
+        this.worker.addEventListener("error", wrapped);
+        return () => this.worker.removeEventListener("error", wrapped);
+      }
+      onClose() {
+        return () => void 0;
+      }
+      terminate() {
+        this.worker.terminate();
+      }
+    };
+  }
+});
+
+// api.ts
+import { DataType, RecordBatchReader, Schema, Table, tableToIPC, vectorFromArray } from "apache-arrow";
+function normalizeArrowInsertOptions(options) {
+  if (!options.name) throw new Error("Arrow insert table name must not be empty");
+  return { name: options.name, schema: options.schema ?? null, create: options.create ?? true };
+}
+function materializeDictionaryColumns(table) {
+  const dictionaryColumns = table.schema.fields.map((field, index) => DataType.isDictionary(field.type) ? index : -1).filter((index) => index !== -1);
+  if (dictionaryColumns.length === 0) return table;
+  const fields = table.schema.fields.map((field) => DataType.isDictionary(field.type) ? field.clone({ type: field.type.dictionary }) : field);
+  const batches = table.batches.map((batch) => {
+    let result = batch;
+    for (const index of dictionaryColumns) {
+      const column = result.getChildAt(index);
+      const sourceField = table.schema.fields[index];
+      if (!column || !sourceField) throw new Error(`Arrow table is missing column ${index}`);
+      const type = sourceField.type;
+      const materialized = vectorFromArray([...column], type.dictionary);
+      result = result.setChildAt(index, materialized);
+    }
+    return result;
+  });
+  return new Table(new Schema(fields, table.schema.metadata, null, table.schema.metadataVersion), batches);
+}
+function readHandleFromResult(result, operation) {
+  if (result.state !== "ok") throw readErrorFromResult(result, operation);
+  if (result.payload.byteLength !== 4) throw new Error(`${operation} returned an invalid handle`);
+  return new DataView(result.payload.buffer, result.payload.byteOffset, result.payload.byteLength).getUint32(0, true);
+}
+function readErrorFromResult(result, operation) {
+  if (result.state === "error" || result.state === "busy") return new Error(result.error);
+  return new Error(`${operation} returned unexpected state ${result.state}`);
+}
+function expectOk(result, operation) {
+  if (result.state !== "ok") throw readErrorFromResult(result, operation);
+}
+function yieldToEventLoop() {
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+var HyperDB = class _HyperDB {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  terminated = false;
+  termination;
+  connections = /* @__PURE__ */ new Set();
+  static async create(options = {}) {
+    const { createBrowserClient: createBrowserClient2 } = await Promise.resolve().then(() => (init_browser(), browser_exports));
+    const database = new _HyperDB(createBrowserClient2(options));
+    await database.ready();
+    return database;
+  }
+  ready() {
+    this.ensureRunning();
+    return this.client.ready();
+  }
+  async connect() {
+    this.ensureRunning();
+    const connection = readHandleFromResult(await this.client.connect(), "connect");
+    const result = new HyperDBConnection(this.client, connection, () => this.connections.delete(result));
+    this.connections.add(result);
+    return result;
+  }
+  async terminate() {
+    if (this.terminated) return;
+    if (!this.termination) {
+      this.termination = (async () => {
+        try {
+          await Promise.all([...this.connections].map(async (connection) => connection.closeForTermination()));
+        } catch (error) {
+          this.termination = void 0;
+          throw error;
+        }
+        this.terminated = true;
+        await this.client.terminate();
+      })();
+    }
+    await this.termination;
+  }
+  ensureRunning() {
+    if (this.terminated) throw new Error("database is terminated");
+  }
+};
+var HyperDBConnection = class {
+  constructor(client, connection, onClose = () => void 0) {
+    this.client = client;
+    this.connection = connection;
+    this.onClose = onClose;
+  }
+  client;
+  connection;
+  onClose;
+  closed = false;
+  active = false;
+  closing;
+  async close() {
+    if (this.closed) return;
+    if (this.active) throw new Error("connection has an active query");
+    if (!this.closing) {
+      this.closing = (async () => {
+        try {
+          expectOk(await this.client.disconnect(this.connection), "disconnect");
+        } catch (error) {
+          this.closing = void 0;
+          throw error;
+        }
+        this.closed = true;
+        this.onClose();
+      })();
+    }
+    await this.closing;
+  }
+  sendIPC(sql) {
+    const connection = this;
+    return {
+      async *[Symbol.asyncIterator]() {
+        connection.ensureAvailable();
+        let query;
+        let terminal = false;
+        let prefetched;
+        try {
+          query = readHandleFromResult(await connection.client.startQuery(connection.connection, sql), "start query");
+          for (; ; ) {
+            let result = prefetched ? await prefetched : await connection.client.pollQuery(query);
+            prefetched = void 0;
+            while (result.state === "pending") {
+              await yieldToEventLoop();
+              result = await connection.client.pollQuery(query);
+            }
+            if (result.state === "chunk") {
+              prefetched = connection.client.pollQuery(query);
+              void prefetched.catch(() => void 0);
+              yield result.payload;
+              continue;
+            }
+            terminal = true;
+            if (result.state === "done") return;
+            throw readErrorFromResult(result, "poll query");
+          }
+        } finally {
+          try {
+            if (query !== void 0) {
+              let cleanupError;
+              if (prefetched) {
+                try {
+                  await prefetched;
+                } catch (error) {
+                  cleanupError = error;
+                }
+                prefetched = void 0;
+              }
+              if (!terminal) {
+                try {
+                  expectOk(await connection.client.cancelQuery(query), "cancel query");
+                } catch (error) {
+                  cleanupError ??= error;
+                }
+              }
+              try {
+                await connection.release(query);
+              } catch (error) {
+                cleanupError ??= error;
+              }
+              if (cleanupError) throw cleanupError;
+            }
+          } finally {
+            connection.active = false;
+          }
+        }
+      }
+    };
+  }
+  async queryIPC(sql) {
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of this.sendIPC(sql)) {
+      chunks.push(chunk);
+      length += chunk.byteLength;
+    }
+    const result = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return result;
+  }
+  async send(sql) {
+    const reader = await RecordBatchReader.from(this.sendIPC(sql));
+    if (!reader.isAsync() || !reader.isStream()) throw new Error("query did not produce an Arrow async stream");
+    return reader;
+  }
+  async query(sql) {
+    const reader = await this.send(sql);
+    const batches = [];
+    for await (const batch of reader) batches.push(batch);
+    return new Table(reader.schema, batches);
+  }
+  async insertArrowTable(table, options) {
+    this.ensureAvailable();
+    let path;
+    try {
+      const result = await this.client.createTemporaryFile(tableToIPC(materializeDictionaryColumns(table), "stream"));
+      expectOk(result, "create temporary Arrow IPC file");
+      path = new TextDecoder().decode(result.payload);
+      await this.insertArrowIPCFromPathInternal(path, options, true, false);
+    } finally {
+      try {
+        if (path !== void 0) expectOk(await this.client.removeFile(path), "remove temporary Arrow IPC file");
+      } finally {
+        this.active = false;
+      }
+    }
+  }
+  async insertArrowIPCFromPath(path, options) {
+    await this.insertArrowIPCFromPathInternal(path, options, false);
+  }
+  async insertArrowIPCFromPathInternal(path, options, internal, acquire = true) {
+    if (!path) throw new Error("Arrow IPC input path must not be empty");
+    const normalized = normalizeArrowInsertOptions(options);
+    if (acquire) this.ensureAvailable();
+    let query;
+    try {
+      query = readHandleFromResult(await this.client.insertArrowIPCFromPath(this.connection, path, normalized.name, normalized.schema, normalized.create, internal), "insert Arrow IPC from path");
+      for (; ; ) {
+        let result = await this.client.pollQuery(query);
+        while (result.state === "pending") {
+          await yieldToEventLoop();
+          result = await this.client.pollQuery(query);
+        }
+        if (result.state === "done") return;
+        if (result.state === "chunk") continue;
+        throw readErrorFromResult(result, "insert Arrow IPC from path");
+      }
+    } finally {
+      try {
+        if (query !== void 0) await this.release(query);
+      } finally {
+        if (acquire) this.active = false;
+      }
+    }
+  }
+  ensureAvailable() {
+    if (this.closed) throw new Error("connection is closed");
+    if (this.closing) throw new Error("connection is closing");
+    if (this.active) {
+      throw new Error("connection has an active query");
+    }
+    this.active = true;
+  }
+  async release(query) {
+    let delay = 1;
+    for (; ; ) {
+      const result = await this.client.releaseQuery(query);
+      if (result.state === "ok") return;
+      if (result.state !== "pending") throw readErrorFromResult(result, "release query");
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      delay = Math.min(delay * 2, 32);
+    }
+  }
+  async closeForTermination() {
+    if (this.active) throw new Error("cannot terminate while a connection has an active query");
+    await this.close();
+  }
+};
+
+// node.ts
+init_client();
+import { Worker as NativeWorker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+var NodeWorker = class {
+  constructor(worker) {
+    this.worker = worker;
+  }
+  worker;
+  postMessage(message, transfer = []) {
+    this.worker.postMessage(message, transfer);
+  }
+  onMessage(listener) {
+    const wrapped = (message) => listener(message);
+    this.worker.on("message", wrapped);
+    return () => this.worker.off("message", wrapped);
+  }
+  onError(listener) {
+    const wrapped = (error) => listener(error instanceof Error ? error : new Error(String(error)));
+    this.worker.on("error", wrapped);
+    return () => this.worker.off("error", wrapped);
+  }
+  onClose(listener) {
+    const wrapped = (code) => listener(new Error(`engine worker exited with code ${String(code)}`));
+    this.worker.on("exit", wrapped);
+    return () => this.worker.off("exit", wrapped);
+  }
+  terminate() {
+    return this.worker.terminate();
+  }
+};
+function resolveNodeEnginePath(engineUrl) {
+  return fileURLToPath(engineUrl);
+}
+function createNodeClient(options = {}) {
+  const workerUrl = options.workerUrl ?? new URL("./node_worker.js", import.meta.url);
+  const engineUrl = options.engineUrl ?? resolveNodeEnginePath(new URL("./hyperdb-wasm.cjs", import.meta.url));
+  return new HyperDBEngineClient(new NodeWorker(new NativeWorker(workerUrl, { workerData: { engineUrl, hostPath: options.hostPath } })));
+}
+
+// index.node.ts
+var HyperDB2 = class _HyperDB extends HyperDB {
+  static async create(options = {}) {
+    const database = new _HyperDB(createNodeClient(options));
+    await database.ready();
+    return database;
+  }
+};
+export {
+  HyperDB2 as HyperDB,
+  HyperDBConnection
+};

package/dist/node_worker.d.ts

@@ -0,0 +1 @@
+export {};