hyperdb-wasm 0.0.27104-dev.wasm.g006f36b4 → 0.0.27104-dev.wasm.g1f6020b7

package/dist/api.d.ts

@@ -10,9 +10,6 @@ export interface HyperDBClient {
     connect(): Promise<WasmResult>;
     disconnect(connection: number): Promise<WasmResult>;
     startQuery(connection: number, sql: string): Promise<WasmResult>;
-    insertArrowIPCFromPath(connection: number, path: string, name: string, schema: string | null, create: boolean, internal?: boolean): Promise<WasmResult>;
-    createTemporaryFile(bytes: Uint8Array): Promise<WasmResult>;
-    removeFile(path: string): Promise<WasmResult>;
     mount(source: MountSource, path: string, mode: MountAccessMode): Promise<WasmResult>;
     unmount(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
@@ -21,10 +18,8 @@ export interface HyperDBClient {
     shutdown(): Promise<WasmResult>;
     terminate(): Promise<void>;
 }
-export interface ArrowInsertOptions {
-    readonly name: string;
-    readonly schema?: string;
-    readonly create?: boolean;
+export interface QueryOptions {
+    readonly signal?: AbortSignal;
 }
 export type MountAccessMode = 'read' | 'readwrite';
 export interface MountOptions {
@@ -113,20 +108,16 @@ export declare class HyperDBConnection {
     private closing;
     constructor(client: HyperDBClient, connection: number, onClose?: () => void);
     close(): Promise<void>;
-    queryStreamIPC(sql: string): QueryStreamIPC;
-    queryIPC(sql: string): QueryPromise<Uint8Array>;
+    queryStreamIPC(sql: string, options?: QueryOptions): QueryStreamIPC;
+    queryIPC(sql: string, options?: QueryOptions): QueryPromise<Uint8Array>;
     queryStream<T extends TypeMap = {
         [key: string]: DataType;
-    }>(sql: string): QueryPromise<AsyncRecordBatchStreamReader<T>>;
+    }>(sql: string, options?: QueryOptions): QueryPromise<AsyncRecordBatchStreamReader<T>>;
     query<T extends TypeMap = {
         [key: string]: DataType;
-    }>(sql: string): QueryPromise<Table<T>>;
-    execute(sql: string): QueryPromise<bigint | null>;
-    insertArrowTable(table: Table, options: ArrowInsertOptions): Promise<void>;
-    insertArrowIPCFromPath(path: string, options: ArrowInsertOptions): Promise<void>;
-    private insertArrowIPCFromPathInternal;
+    }>(sql: string, options?: QueryOptions): QueryPromise<Table<T>>;
+    execute(sql: string, options?: QueryOptions): QueryPromise<bigint | null>;
     private ensureAvailable;
-    private finishQuery;
     closeForTermination(): Promise<void>;
 }
 export type { HyperDBEngineClient };

package/dist/browser.js

@@ -112,16 +112,6 @@ var init_client = __esm({
       startQuery(connection, sql, sqlTestMode = false) {
         return this.request({ id: this.nextId++, type: "startQuery", connection, sql, ...sqlTestMode && { sqlTestMode } });
       }
-      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 });
-      }
       mount(source, path, mode) {
         return this.request({ id: this.nextId++, type: "mount", source, path, mode });
       }
@@ -282,7 +272,7 @@ var init_browser = __esm({
 });
 
 // src/api.ts
-import { DataType, RecordBatchReader, Schema, Table, tableToIPC, vectorFromArray } from "apache-arrow";
+import { RecordBatchReader, Table } from "apache-arrow";
 function validateMountPath(path) {
   if (typeof path !== "string" || !path.startsWith("/mnt/external/")) {
     throw new Error("Mount path must be an absolute path below /mnt/external");
@@ -373,28 +363,6 @@ function decodeQueryInfo(payload) {
     executionMetrics: value.executionMetrics
   };
 }
-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`);
@@ -419,6 +387,118 @@ async function initializeHyperDB(client, settings) {
 function yieldToEventLoop() {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }
+async function finishEngineQuery(client, query) {
+  let delay = 1;
+  for (; ; ) {
+    const result = await client.finishQuery(query);
+    if (result.state === "ok") return result.payload;
+    if (result.state !== "pending") throw readErrorFromResult(result, "finish query");
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    delay = Math.min(delay * 2, 32);
+  }
+}
+var EngineQueryOperation = class {
+  constructor(client, signal, onAbort = () => void 0) {
+    this.client = client;
+    this.signal = signal;
+    this.onAbort = onAbort;
+  }
+  client;
+  signal;
+  onAbort;
+  abortResult = deferred();
+  query;
+  terminal = false;
+  abortAccepted = false;
+  cancellation;
+  finalization;
+  get started() {
+    return this.query !== void 0;
+  }
+  get completed() {
+    return this.terminal;
+  }
+  get aborted() {
+    return this.abortAccepted;
+  }
+  get abortReason() {
+    return this.signal?.reason;
+  }
+  async start(start, operation) {
+    this.signal?.throwIfAborted();
+    this.signal?.addEventListener("abort", this.handleAbort, { once: true });
+    try {
+      this.query = readHandleFromResult(await start(), operation);
+      if (this.signal?.aborted) this.acceptAbort();
+      this.throwIfAborted();
+    } catch (error) {
+      if (this.query === void 0) this.detachAbortListener();
+      throw error;
+    }
+  }
+  poll() {
+    if (this.query === void 0) throw new Error("query has not started");
+    return this.client.pollQuery(this.query);
+  }
+  markCompleted() {
+    this.terminal = true;
+  }
+  throwIfAborted() {
+    if (this.abortAccepted) throw this.abortReason;
+  }
+  interrupt(result) {
+    return Promise.race([result, this.abortResult.promise]);
+  }
+  finish() {
+    if (!this.finalization) this.finalization = this.finishOnce();
+    return this.finalization;
+  }
+  handleAbort = () => {
+    this.acceptAbort();
+  };
+  acceptAbort() {
+    if (this.terminal) return;
+    const firstAbort = !this.abortAccepted;
+    this.abortAccepted = true;
+    if (firstAbort) this.abortResult.reject(this.abortReason);
+    void this.requestCancellation();
+    if (firstAbort) this.onAbort();
+  }
+  requestCancellation() {
+    if (this.query === void 0 || this.terminal) return this.cancellation;
+    if (!this.cancellation) {
+      const query = this.query;
+      this.cancellation = (async () => {
+        expectOk(await this.client.cancelQuery(query), "cancel query");
+      })();
+      void this.cancellation.catch(() => void 0);
+    }
+    return this.cancellation;
+  }
+  async finishOnce() {
+    this.detachAbortListener();
+    if (this.query === void 0) return void 0;
+    let cleanupError;
+    if (!this.terminal) {
+      try {
+        await this.requestCancellation();
+      } catch (error) {
+        cleanupError = error;
+      }
+    }
+    let payload;
+    try {
+      payload = await finishEngineQuery(this.client, this.query);
+    } catch (error) {
+      cleanupError ??= error;
+    }
+    if (cleanupError) throw cleanupError;
+    return payload;
+  }
+  detachAbortListener() {
+    this.signal?.removeEventListener("abort", this.handleAbort);
+  }
+};
 var MountedResourceImpl = class {
   constructor(path, unmount, cleanup) {
     this.path = path;
@@ -583,41 +663,48 @@ var HyperDBConnection = class {
     }
     await this.closing;
   }
-  queryStreamIPC(sql) {
+  queryStreamIPC(sql, options = {}) {
     const connection = this;
+    const signal = options.signal;
     const queryInfo = deferred();
-    const result = (async function* () {
-      let query;
-      let terminal = false;
+    let generator;
+    let abortDelivered = false;
+    const operation = new EngineQueryOperation(connection.client, signal, () => {
+      void generator.return(void 0).catch(() => void 0);
+    });
+    generator = (async function* () {
       let prefetched;
       let acquired = false;
       try {
         connection.ensureAvailable();
         acquired = true;
-        query = readHandleFromResult(await connection.client.startQuery(connection.connection, sql), "start query");
+        await operation.start(() => connection.client.startQuery(connection.connection, sql), "start query");
         for (; ; ) {
-          let result2 = prefetched ? await prefetched : await connection.client.pollQuery(query);
+          let result2 = prefetched ? await prefetched : await operation.poll();
           prefetched = void 0;
+          operation.throwIfAborted();
           while (result2.state === "pending") {
             await yieldToEventLoop();
-            result2 = await connection.client.pollQuery(query);
+            operation.throwIfAborted();
+            result2 = await operation.poll();
+            operation.throwIfAborted();
           }
           if (result2.state === "chunk") {
-            prefetched = connection.client.pollQuery(query);
+            prefetched = operation.poll();
             void prefetched.catch(() => void 0);
             yield result2.payload;
             continue;
           }
-          terminal = true;
+          operation.markCompleted();
           if (result2.state === "done") return;
           throw readErrorFromResult(result2, "poll query");
         }
       } catch (error) {
-        if (query === void 0 || !terminal) queryInfo.reject(error);
+        if (!operation.started || !operation.completed && !operation.aborted) queryInfo.reject(error);
         throw error;
       } finally {
         try {
-          if (query !== void 0) {
+          if (operation.started) {
             let cleanupError;
             let info;
             if (prefetched) {
@@ -628,15 +715,9 @@ var HyperDBConnection = class {
               }
               prefetched = void 0;
             }
-            if (!terminal) {
-              try {
-                expectOk(await connection.client.cancelQuery(query), "cancel query");
-              } catch (error) {
-                cleanupError ??= error;
-              }
-            }
             try {
-              info = decodeQueryInfo(await connection.finishQuery(query));
+              const payload = await operation.finish();
+              if (payload) info = decodeQueryInfo(payload);
             } catch (error) {
               cleanupError ??= error;
             }
@@ -645,16 +726,37 @@ var HyperDBConnection = class {
               throw cleanupError;
             }
             queryInfo.resolve(info);
+          } else {
+            await operation.finish();
           }
         } finally {
           if (acquired) connection.active = false;
         }
       }
     })();
+    const result = {
+      [Symbol.asyncIterator]() {
+        return {
+          next() {
+            if (operation.aborted && !abortDelivered) {
+              abortDelivered = true;
+              return Promise.reject(operation.abortReason);
+            }
+            return operation.interrupt(generator.next());
+          },
+          return(value) {
+            return generator.return(value);
+          },
+          throw(error) {
+            return generator.throw(error);
+          }
+        };
+      }
+    };
     return queryIPCStream(result, queryInfo.promise);
   }
-  queryIPC(sql) {
-    const stream = this.queryStreamIPC(sql);
+  queryIPC(sql, options = {}) {
+    const stream = this.queryStreamIPC(sql, options);
     const result = (async () => {
       const chunks = [];
       let length = 0;
@@ -672,8 +774,8 @@ var HyperDBConnection = class {
     })();
     return queryPromise(result, stream.info);
   }
-  queryStream(sql) {
-    const stream = this.queryStreamIPC(sql);
+  queryStream(sql, options = {}) {
+    const stream = this.queryStreamIPC(sql, options);
     const result = (async () => {
       const reader = await RecordBatchReader.from(stream);
       if (!reader.isAsync() || !reader.isStream()) throw new Error("query did not produce an Arrow async stream");
@@ -683,8 +785,8 @@ var HyperDBConnection = class {
     })();
     return queryPromise(result, stream.info);
   }
-  query(sql) {
-    const stream = this.queryStream(sql);
+  query(sql, options = {}) {
+    const stream = this.queryStream(sql, options);
     const result = (async () => {
       const reader = await stream;
       const batches = [];
@@ -693,8 +795,8 @@ var HyperDBConnection = class {
     })();
     return queryPromise(result, stream.info);
   }
-  execute(sql) {
-    const stream = this.queryStreamIPC(sql);
+  execute(sql, options = {}) {
+    const stream = this.queryStreamIPC(sql, options);
     const result = (async () => {
       for await (const _chunk of stream) {
       }
@@ -702,50 +804,6 @@ var HyperDBConnection = class {
     })();
     return queryPromise(result, stream.info);
   }
-  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.finishQuery(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");
@@ -754,16 +812,6 @@ var HyperDBConnection = class {
     }
     this.active = true;
   }
-  async finishQuery(query) {
-    let delay = 1;
-    for (; ; ) {
-      const result = await this.client.finishQuery(query);
-      if (result.state === "ok") return result.payload;
-      if (result.state !== "pending") throw readErrorFromResult(result, "finish 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 operation");
     await this.close();

package/dist/browser_worker.js

@@ -64,14 +64,12 @@
     projectExternalFile;
     projectExternalDirectory;
     startQuery;
-    insertArrowIPCFromPath;
     pollQuery;
     cancelQuery;
     finishQuery;
     resultState;
     resultPayloadLength;
     free;
-    nextTemporaryFile = 1;
     mountedPaths = /* @__PURE__ */ new Set();
     constructor(module) {
       this.module = module;
@@ -85,7 +83,6 @@
       this.projectExternalFile = module.cwrap("hyperdb_wasm_project_external_file", "pointer", ["string", "string", "number"]);
       this.projectExternalDirectory = module.cwrap("hyperdb_wasm_project_external_directory", "pointer", ["string", "string"]);
       this.startQuery = module.cwrap("hyperdb_wasm_query_start", "pointer", ["number", "string", "number"]);
-      this.insertArrowIPCFromPath = module.cwrap("hyperdb_wasm_arrow_insert_from_path", "pointer", ["number", "string", "string", "string", "number"]);
       this.pollQuery = module.cwrap("hyperdb_wasm_query_poll", "pointer", ["number"]);
       this.cancelQuery = module.cwrap("hyperdb_wasm_query_cancel", "pointer", ["number"]);
       this.finishQuery = module.cwrap("hyperdb_wasm_query_finish", "pointer", ["number"]);
@@ -94,16 +91,6 @@
       this.free = module.cwrap("hyperdb_wasm_free", null, ["pointer"]);
     }
     handle(request) {
-      if (request.type === "createTemporaryFile") {
-        const path = `/tmp/hyperdb/arrow-${this.nextTemporaryFile++}.arrows`;
-        this.module.FS.mkdirTree("/tmp/hyperdb");
-        this.module.FS.writeFile(path, request.bytes);
-        return { response: { id: request.id, type: "response", result: { state: "ok", payload: new TextEncoder().encode(path) } }, transfer: [] };
-      }
-      if (request.type === "removeFile") {
-        this.module.FS.unlink(request.path);
-        return { response: { id: request.id, type: "response", result: { state: "ok", payload: new Uint8Array() } }, transfer: [] };
-      }
       if (request.type === "mount" && request.source.kind === "node-path") {
         if (!this.module.externalFileBackend) {
           return { response: { id: request.id, type: "response", result: { state: "error", error: "Host external files are supported only by the Node client" } }, transfer: [] };
@@ -176,13 +163,6 @@
         case "startQuery":
           validateCStringContents(request.sql, "SQL");
           return this.startQuery(request.connection, request.sql, Number(request.sqlTestMode ?? false));
-        case "insertArrowIPCFromPath": {
-          const path = request.internal || request.path.startsWith("/mnt/external/") ? request.path : this.module.resolveHyperDBPath?.(request.path) ?? request.path;
-          validateCString(path, "Arrow IPC input path");
-          validateCString(request.name, "Arrow insert table name");
-          validateCStringContents(request.schema ?? "", "Arrow insert schema name");
-          return this.insertArrowIPCFromPath(request.connection, path, request.name, request.schema ?? "", Number(request.create));
-        }
         case "pollQuery":
           return this.pollQuery(request.query);
         case "cancelQuery":
@@ -333,12 +313,6 @@
         return hasKeys(value, ["id", "type"]);
       case "startQuery":
         return (hasKeys(value, ["id", "type", "connection", "sql"]) || hasKeys(value, ["id", "type", "connection", "sql", "sqlTestMode"])) && Number.isSafeInteger(value.connection) && typeof value.sql === "string" && (value.sqlTestMode === void 0 || typeof value.sqlTestMode === "boolean");
-      case "insertArrowIPCFromPath":
-        return hasKeys(value, ["id", "type", "connection", "path", "name", "schema", "create", "internal"]) && Number.isSafeInteger(value.connection) && typeof value.path === "string" && typeof value.name === "string" && (typeof value.schema === "string" || value.schema === null) && typeof value.create === "boolean" && typeof value.internal === "boolean";
-      case "createTemporaryFile":
-        return hasKeys(value, ["id", "type", "bytes"]) && value.bytes instanceof Uint8Array;
-      case "removeFile":
-        return hasKeys(value, ["id", "type", "path"]) && typeof value.path === "string";
       case "mount": {
         if (!hasKeys(value, ["id", "type", "source", "path", "mode"]) || typeof value.path !== "string" || !value.path.startsWith("/mnt/external/") || new TextEncoder().encode(value.path.slice("/mnt/external/".length)).byteLength === 0 || new TextEncoder().encode(value.path.slice("/mnt/external/".length)).byteLength > 200 || value.path.slice("/mnt/external/".length).split("/").some((component) => !component || component === "." || component === ".." || !/^[A-Za-z0-9._-]+$/.test(component)) || value.mode !== "read" && value.mode !== "readwrite" || !isRecord(value.source)) return false;
         switch (value.source.kind) {
@@ -986,10 +960,6 @@
       if (storagePath) runtime.FS.mkdirTree(`/mnt/fs/${storagePath}`);
       runtime.FS.mkdirTree(`${storagePath ? `/mnt/fs/${storagePath}` : "/mnt/fs"}/logs`);
       runtime.hyperdbWasmStoragePath = storagePath;
-      runtime.resolveHyperDBPath = (path) => {
-        const relativePath = normalizeStoragePath(path);
-        return `/mnt/fs/${relativePath}`;
-      };
     });
     self.importScripts(resolvedEngineUrl.href);
   }

package/dist/client.d.ts

@@ -17,9 +17,6 @@ export declare class HyperDBEngineClient {
     disconnect(connection: number): Promise<WasmResult>;
     shutdown(): Promise<WasmResult>;
     startQuery(connection: number, sql: string, sqlTestMode?: boolean): Promise<WasmResult>;
-    insertArrowIPCFromPath(connection: number, path: string, name: string, schema: string | null, create: boolean, internal?: boolean): Promise<WasmResult>;
-    createTemporaryFile(bytes: Uint8Array): Promise<WasmResult>;
-    removeFile(path: string): Promise<WasmResult>;
     mount(source: MountSource, path: string, mode: MountAccessMode): Promise<WasmResult>;
     unmount(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;