@surrealdb/wasm-native 3.3.4 → 4.0.0-beta.1

package/dist/index_bg.wasm.d.ts

@@ -1,17 +1,10 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
-export const __wbg_surrealwasmengine_free: (a: number, b: number) => void;
-export const surrealwasmengine_connect: (a: number, b: number, c: number) => number;
-export const surrealwasmengine_execute: (a: number, b: number, c: number) => number;
-export const surrealwasmengine_export: (a: number, b: number, c: number) => number;
-export const surrealwasmengine_import: (a: number, b: number, c: number) => number;
-export const surrealwasmengine_notifications: (a: number) => number;
-export const surrealwasmengine_query_stream: (a: number, b: number, c: number) => number;
-export const surrealwasmengine_version: (a: number) => void;
 export const __wbg_intounderlyingbytesource_free: (a: number, b: number) => void;
 export const __wbg_intounderlyingsink_free: (a: number, b: number) => void;
 export const __wbg_intounderlyingsource_free: (a: number, b: number) => void;
+export const __wbg_surrealwasmengine_free: (a: number, b: number) => void;
 export const intounderlyingbytesource_autoAllocateChunkSize: (a: number) => number;
 export const intounderlyingbytesource_cancel: (a: number) => void;
 export const intounderlyingbytesource_pull: (a: number, b: number) => number;
@@ -22,11 +15,28 @@ export const intounderlyingsink_close: (a: number) => number;
 export const intounderlyingsink_write: (a: number, b: number) => number;
 export const intounderlyingsource_cancel: (a: number) => void;
 export const intounderlyingsource_pull: (a: number, b: number) => number;
-export const __wasm_bindgen_func_elem_29890: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_4538: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_29891: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_4606: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_8031: (a: number, b: number) => void;
+export const surrealwasmengine_close: (a: number) => number;
+export const surrealwasmengine_connect: (a: number, b: number, c: number) => number;
+export const surrealwasmengine_execute: (a: number, b: number, c: number) => number;
+export const surrealwasmengine_export: (a: number, b: number, c: number) => number;
+export const surrealwasmengine_import: (a: number, b: number, c: number) => number;
+export const surrealwasmengine_notifications: (a: number) => number;
+export const surrealwasmengine_persisted: () => number;
+export const surrealwasmengine_query_stream: (a: number, b: number, c: number) => number;
+export const surrealwasmengine_version: (a: number) => void;
+export const rust_zstd_wasm_shim_calloc: (a: number, b: number) => number;
+export const rust_zstd_wasm_shim_free: (a: number) => void;
+export const rust_zstd_wasm_shim_malloc: (a: number) => number;
+export const rust_zstd_wasm_shim_memcmp: (a: number, b: number, c: number) => number;
+export const rust_zstd_wasm_shim_memcpy: (a: number, b: number, c: number) => number;
+export const rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number;
+export const rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number;
+export const rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_5798: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_5862: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_46027: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_46027_22: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_9452: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;

package/dist/worker.js

@@ -0,0 +1,86 @@
+// ts/worker.ts
+var wasm;
+var engine;
+var inFlight = new Set;
+function tracked(work) {
+  inFlight.add(work);
+  const done = () => inFlight.delete(work);
+  work.then(done, done);
+  return work;
+}
+function loaded() {
+  if (!wasm)
+    throw new Error("The engine module has not been initialised");
+  return wasm;
+}
+function connected() {
+  if (!engine)
+    throw new Error("The engine is not connected");
+  return engine;
+}
+function describe(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function handle(request) {
+  switch (request.op) {
+    case "init": {
+      wasm = await import(new URL("./index.js", import.meta.url).href);
+      await wasm.default(request.module ? { module_or_path: request.module } : undefined);
+      return {};
+    }
+    case "connect": {
+      if (engine)
+        throw new Error("The worker already hosts an engine");
+      engine = await loaded().SurrealWasmEngine.connect(request.endpoint, request.options);
+      return {};
+    }
+    case "execute": {
+      const value = await tracked(connected().execute(request.data));
+      return { value, transfer: [value.buffer] };
+    }
+    case "queryStream": {
+      const value = await tracked(connected().query_stream(request.data));
+      return { value, transfer: [value] };
+    }
+    case "notifications": {
+      const value = connected().notifications();
+      return { value, transfer: [value] };
+    }
+    case "export":
+      return { value: await tracked(connected().export(request.config)) };
+    case "import":
+      await tracked(connected().import(request.input));
+      return {};
+    case "version":
+      return { value: loaded().SurrealWasmEngine.version() };
+    case "persisted":
+      return { value: await loaded().SurrealWasmEngine.persisted() };
+    case "close": {
+      const closing = engine;
+      engine = undefined;
+      if (closing) {
+        await closing.close();
+        await Promise.allSettled([...inFlight]);
+        closing.free();
+      }
+      return {};
+    }
+  }
+}
+var dedicated = (() => {
+  const scope = globalThis.DedicatedWorkerGlobalScope;
+  return scope !== undefined && self instanceof scope;
+})();
+self.onmessage = async (event) => {
+  if (!dedicated || event.origin !== "")
+    return;
+  const request = event.data;
+  try {
+    const { value, transfer } = await handle(request);
+    const reply = { id: request.id, ok: true, value };
+    self.postMessage(reply, transfer ?? []);
+  } catch (error) {
+    const reply = { id: request.id, ok: false, error: describe(error) };
+    self.postMessage(reply);
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@surrealdb/wasm-native",
-	"version": "3.3.4",
+	"version": "4.0.0-beta.1",
 	"type": "module",
 	"license": "Apache-2.0",
 	"description": "WebAssembly bindings to an embedded SurrealDB engine, for the browser",
@@ -29,6 +29,10 @@
 			"import": "./dist/index.js",
 			"types": "./dist/index.d.ts"
 		},
+		"./worker": {
+			"import": "./dist/client.js",
+			"types": "./dist/client.d.ts"
+		},
 		"./module": "./dist/index_bg.wasm"
 	},
 	"files": [

package/dist/snippets/surrealdb-kvs-indxdb-977c9aafa2968a33/src/js/db.js

@@ -1,357 +0,0 @@
-// IndexedDB driver for the surrealdb-kvs-indxdb backend.
-//
-// IndexedDB transactions go inactive whenever an await crosses a
-// non-IndexedDB microtask, so a single IndexedDB transaction cannot span a
-// Rust-side kvs transaction. Instead every read runs in its own short-lived
-// readonly transaction, and `Tx.commit` validates the accumulated read-set
-// and applies the write-set atomically inside one readwrite transaction that
-// only ever awaits IndexedDB requests (which keeps it active).
-//
-// The database layout matches the layout previously created by the `indxdb`
-// crate: a single object store named "kv" (database version 1) with
-// out-of-line binary keys and Uint8Array values, so databases created by
-// older versions open without migration. Future layout changes must bump the
-// database version and migrate in `onupgradeneeded`.
-
-// Read-state flags, low nibble of a commit entry flag byte.
-const READ_UNKNOWN = 0;
-const READ_EXISTS = 1;
-const READ_READ = 2;
-const READ_EMPTY = 3;
-
-// Write-state flags, high nibble of a commit entry flag byte.
-const WRITE_UNCHANGED = 0;
-const WRITE_WRITTEN = 1;
-const WRITE_DELETED = 2;
-
-function promiseReq(req) {
-	return new Promise((resolve, reject) => {
-		req.onsuccess = () => resolve(req.result);
-		req.onerror = () => reject(req.error);
-	});
-}
-
-// IndexedDB hands binary keys back as ArrayBuffer and values in whatever
-// shape they were stored in; normalize both to Uint8Array.
-function toBytes(value) {
-	if (value instanceof Uint8Array) {
-		return value;
-	}
-	return new Uint8Array(value);
-}
-
-function bytesEqual(a, b) {
-	if (a.length !== b.length) {
-		return false;
-	}
-	for (let i = 0; i < a.length; i += 1) {
-		if (a[i] !== b[i]) {
-			return false;
-		}
-	}
-	return true;
-}
-
-const EMPTY_BATCH = {
-	keys: new Uint8Array(0),
-	keyEnds: new Uint32Array(0),
-	values: null,
-	valueEnds: null,
-};
-
-export class Tx {
-	constructor(db) {
-		this.db = db;
-	}
-
-	store(mode) {
-		return this.db.transaction("kv", mode).objectStore("kv");
-	}
-
-	async read(key) {
-		const value = await promiseReq(this.store("readonly").get(key));
-		return value === undefined ? null : toBytes(value);
-	}
-
-	async has(key) {
-		const count = await promiseReq(this.store("readonly").count(key));
-		return count > 0;
-	}
-
-	scan(start, end, reverse, limit, keysOnly) {
-		if (limit === 0) {
-			// ensure we always return a promise.
-			return new Promise((res) => res(EMPTY_BATCH));
-		}
-
-		let range;
-		try {
-			// Start inclusive, end exclusive.
-			range = IDBKeyRange.bound(start, end, false, true);
-		} catch {
-			// Thrown when start >= end: an empty range.
-			// ensure we always return a promise.
-			return new Promise((res) => res(EMPTY_BATCH));
-		}
-
-		const keys = [];
-		const values = keysOnly ? null : [];
-
-		const store = this.store("readonly");
-		const direction = reverse ? "prev" : "next";
-		const req = keysOnly
-			? store.getAllKeys({ query: range, count: limit, direction })
-			: store.getAllRecords({ query: range, count: limit, direction })
-
-		return new Promise((resolve, reject) => {
-			req.onsuccess = () => {
-
-				const results = req.result;
-				const resLength = results.length;
-
-				let valuesLen = 0;
-				let keysLen = 0;
-
-				if (keysOnly){
-					for(let i = 0;i < resLength;i++){
-						keysLen += results[i].byteLength;
-					}
-				}else{
-					for(let i = 0;i < resLength;i++){
-						keysLen += results[i].key.byteLength;
-						valuesLen += results[i].value.byteLength;
-					}
-				}
-
-				const keyEnds = new Uint32Array(resLength);
-
-				const keys = new Uint8Array(keysLen);
-
-				if (keysOnly) {
-					let offset = 0;
-					for(let i = 0;i < resLength;i++){
-						const bytes = toBytes(results[i]);
-						keys.set(bytes,offset);
-						offset += bytes.length;
-						keyEnds[i] = offset;
-					}
-
-					// No values were read: signal that explicitly instead of
-					// returning empty buffers, which the Rust side would split
-					// into one empty value per key.
-					return resolve({
-						keys,
-						keyEnds,
-						values: null,
-						valueEnds: null,
-					});
-				}
-
-				const valueEnds = new Uint32Array(resLength);
-				const values = new Uint8Array(valuesLen);
-
-				let koffset = 0;
-				let voffset = 0;
-				for(let i = 0;i < resLength;i++){
-
-					const kbytes = toBytes(results[i].key);
-					keys.set(kbytes,koffset);
-					koffset += kbytes.length;
-					keyEnds[i] = koffset;
-
-					const vbytes = toBytes(results[i].value);
-					values.set(vbytes,voffset);
-					voffset += vbytes.length;
-					valueEnds[i] = voffset;
-				}
-
-				return resolve({
-					keys,
-					keyEnds,
-					values,
-					valueEnds,
-				});
-
-
-			};
-			req.onerror = () => reject(req.error);
-		});
-
-	}
-
-	async commit(keys, keySlices, read, readSlices, written, writtenSlices, flags) {
-		// The typed-array arguments may be views into wasm memory. While this
-		// function awaits, other wasm tasks can run and grow the wasm memory,
-		// detaching those views. So we need to copy read before the first await as it
-		// might be used after an await.
-		read = read.slice();
-
-		const tx = this.db.transaction("kv", "readwrite");
-		const store = tx.objectStore("kv");
-
-		let readIdx = 0;
-		let writeIdx = 0;
-
-		// To improve speed we issue all read checks in parallel and do not wait for
-		// the request to return instead checking once at the end if all the checks
-		// succeeded.
-		let conflict = false;
-		let pendingChecks = 0;
-
-		const fail = () => {
-			if (!conflict) {
-				conflict = true;
-				tx.abort();
-			}
-		};
-
-		// Explicitly committing skips one idle event-loop turn, but is only
-		// legal once no validation can still abort: after commit() the
-		// transaction enters the committing state where abort() throws.
-		const checkDone = () => {
-			pendingChecks -= 1;
-			if (pendingChecks === 0 && !conflict && tx.commit) {
-				tx.commit();
-			}
-		};
-
-		// All requests are fired without awaiting; IndexedDB executes them in
-		// issue order within the transaction, so every validation read of a
-		// key observes the pre-transaction state (each key appears at most
-		// once). This pipelines the whole commit into a single pass instead
-		// of one event-loop round trip per validated key.
-		for (let i = 0; i < flags.length; i += 1) {
-			const readFlag = flags[i] & 0xf;
-			const writeFlag = flags[i] >> 4;
-
-			const key = keys.subarray(keySlices[i * 2], keySlices[i * 2 + 1]);
-
-			switch (readFlag) {
-				case READ_EMPTY: {
-					pendingChecks += 1;
-					const req = store.count(key);
-					req.onsuccess = () => {
-						if (req.result !== 0) {
-							fail();
-						} else {
-							checkDone();
-						}
-					};
-					break;
-				}
-				case READ_EXISTS: {
-					pendingChecks += 1;
-					const req = store.count(key);
-					req.onsuccess = () => {
-						if (req.result === 0) {
-							fail();
-						} else {
-							checkDone();
-						}
-					};
-					break;
-				}
-				case READ_READ: {
-					const idx = readIdx;
-					readIdx += 1;
-					const expect = read.subarray(readSlices[idx * 2], readSlices[idx * 2 + 1]);
-					pendingChecks += 1;
-					const req = store.get(key);
-					req.onsuccess = () => {
-						const value = req.result;
-						if (value === undefined || !bytesEqual(toBytes(value), expect)) {
-							fail();
-						} else {
-							checkDone();
-						}
-					};
-					break;
-				}
-				default:
-					break;
-			}
-
-			switch (writeFlag) {
-				case WRITE_DELETED: {
-					store.delete(key);
-					break;
-				}
-				case WRITE_WRITTEN: {
-					const idx = writeIdx;
-					writeIdx += 1;
-					// slice(), not subarray(): the structured clone of a view
-					// serializes its entire backing buffer, so storing a
-					// subarray would persist a copy of the whole packed
-					// commit payload with every entry.
-					const value = written.slice(writtenSlices[idx * 2], writtenSlices[idx * 2 + 1]);
-					store.put(value, key);
-					break;
-				}
-				default:
-					break;
-			}
-		}
-
-		const applied = await new Promise((resolve, reject) => {
-			tx.oncomplete = () => resolve(true);
-			tx.onabort = () =>
-				conflict ? resolve(false) : reject(tx.error ?? new Error("transaction aborted"));
-			// Swallow per-request error events (an abort after a failed
-			// validation errors every later queued request) without
-			// cancelling their default action, so a genuine request failure
-			// still aborts the transaction and surfaces via onabort.
-			tx.onerror = () => {};
-			if (pendingChecks === 0 && tx.commit) {
-				tx.commit();
-			}
-		});
-		return applied;
-	}
-}
-
-export class Db {
-	constructor(db) {
-		this.db = db;
-	}
-
-	begin() {
-		return new Tx(this.db);
-	}
-
-	close() {
-		this.db.close();
-	}
-}
-
-export function open(name) {
-	return new Promise((resolve, reject) => {
-		if (typeof indexedDB === "undefined") {
-			reject(new Error("IndexedDB api is not supported on this platform"));
-			return;
-		}
-
-		const req = indexedDB.open(name, 1);
-
-		req.onerror = () => reject(req.error);
-
-		req.onupgradeneeded = () => {
-			// Fresh database: create the store in the indxdb-crate-compatible
-			// layout described at the top of this file.
-			req.result.createObjectStore("kv");
-		};
-
-		req.onsuccess = () => {
-			const db = req.result;
-			if (!db.objectStoreNames.contains("kv")) {
-				db.close();
-				reject(new Error(`indexedDB database ${name} is missing the "kv" object store`));
-			} else {
-				resolve(new Db(db));
-			}
-		};
-	});
-}
-
-export function to_string(v){
-	return v.toString()
-}