@minnowdb/core 0.7.0 → 0.7.1

package/dist/testing/opfs-shim.js

@@ -1,329 +1,297 @@
-/**
- * An in-memory Origin Private File System for Node tests: enough of
- * `FileSystemDirectoryHandle` / `FileSystemFileHandle` / `FileSystemSyncAccessHandle` for the
- * OPFS block store, with the semantics that make OPFS interesting to test against:
- *
- * - **Exclusive sync-access locks.** One open handle per file across every directory handle on
- *   the same shim — a second `createSyncAccessHandle` throws `NoModificationAllowedError`,
- *   exactly the cross-tab arbitration the store's command log builds on. `getFile` and
- *   `removeEntry` on a locked file also refuse, the strictest reading of the underspecified
- *   parts of the spec, so a store that passes here never depends on browser-specific leniency.
- * - **Real DOMException identities.** `NotFoundError`, `TypeMismatchError`,
- *   `InvalidModificationError`, `NoModificationAllowedError`, and injected
- *   `QuotaExceededError`s are actual `DOMException`s, since error identity is part of the
- *   storage contract.
- * - **Injectable write faults and short transfers.** `setWriteFault` throws from inside sync
- *   writes, creates, or flushes; `setTransferLimit` makes reads or writes return any valid short
- *   byte count, including zero progress, at deterministic offsets.
- *
- * For applications, `MemoryBlockStore` remains the right store in Node tests. This shim is for
- * adapter authors: it hosts `OpfsBlockStore` (pass `root`) or anything built on the storage
- * toolkit's `SyncFileHandle` surface, in plain vitest, with crashes and quota failures on tap.
- */
-export class MemoryOpfs {
-    #rootNode = { kind: "directory", name: "", children: new Map() };
-    #writeFault = null;
-    #deleteFault = null;
-    #transferLimit = null;
-    /** The tree's root, shaped like `navigator.storage.getDirectory()`'s result. */
-    get root() {
-        return new ShimDirectoryHandle(this, this.#rootNode, "");
-    }
-    /** Installs (or clears, with `null`) a fault thrown from inside write paths. */
-    setWriteFault(fault) {
-        this.#writeFault = fault;
-    }
-    /** Installs a fault at file/directory removal, for post-commit cleanup tests. */
-    setDeleteFault(fault) {
-        this.#deleteFault = fault;
-    }
-    /** Limits individual sync-handle transfers so tests can deterministically exercise short I/O. */
-    setTransferLimit(limit) {
-        this.#transferLimit = limit;
-    }
-    maybeFault(path, phase) {
-        this.#writeFault?.(path, phase);
-    }
-    maybeDeleteFault(path) {
-        this.#deleteFault?.(path);
-    }
-    limitTransfer(path, operation, requestedBytes, at) {
-        const limited = this.#transferLimit?.(path, operation, requestedBytes, at) ?? requestedBytes;
-        if (!Number.isSafeInteger(limited) || limited < 0 || limited > requestedBytes) {
-            throw new RangeError(`Invalid test transfer limit ${String(limited)} for ${String(requestedBytes)} requested bytes`);
-        }
-        return limited;
-    }
-    /** Test-side peek: the file's current bytes, or undefined. Bypasses locks on purpose. */
-    readFileBytes(path) {
-        const node = this.#find(path);
-        return node?.kind === "file" ? node.bytes.slice() : undefined;
-    }
-    /** Test-side poke: writes bytes directly, creating parents. Bypasses locks on purpose. */
-    writeFileBytes(path, bytes) {
-        const segments = path.split("/").filter((segment) => segment.length > 0);
-        const name = segments.pop();
-        if (name === undefined)
-            throw new Error("A file path cannot be empty");
-        let directory = this.#rootNode;
-        for (const segment of segments) {
-            let child = directory.children.get(segment);
-            if (child === undefined) {
-                child = { kind: "directory", name: segment, children: new Map() };
-                directory.children.set(segment, child);
-            }
-            if (child.kind !== "directory")
-                throw new Error(`Not a directory: ${segment}`);
-            directory = child;
-        }
-        const existing = directory.children.get(name);
-        if (existing?.kind === "directory")
-            throw new Error(`Not a file: ${path}`);
-        directory.children.set(name, {
-            kind: "file",
-            name,
-            bytes: bytes.slice(),
-            lockHolder: existing?.lockHolder ?? null,
-        });
-    }
-    /** Test-side in-place corruption: existing sync handles observe the changed byte. */
-    corruptFileByte(path, offset) {
-        const node = this.#find(path);
-        if (node?.kind !== "file")
-            throw new Error(`Not a file: ${path}`);
-        if (!Number.isSafeInteger(offset) || offset < 0 || offset >= node.bytes.byteLength) {
-            throw new RangeError(`Invalid corruption offset ${String(offset)} for ${path}`);
-        }
-        node.bytes[offset] = (node.bytes[offset] ?? 0) ^ 0xff;
-    }
-    #find(path) {
-        let node = this.#rootNode;
-        for (const segment of path.split("/").filter((segment) => segment.length > 0)) {
-            if (node.kind !== "directory")
-                return undefined;
-            const child = node.children.get(segment);
-            if (child === undefined)
-                return undefined;
-            node = child;
-        }
-        return node;
-    }
+class MemoryOpfs {
+  #rootNode = { kind: "directory", name: "", children: /* @__PURE__ */ new Map() };
+  #writeFault = null;
+  #deleteFault = null;
+  #transferLimit = null;
+  get root() {
+    return new ShimDirectoryHandle(this, this.#rootNode, "");
+  }
+  setWriteFault(fault) {
+    this.#writeFault = fault;
+  }
+  setDeleteFault(fault) {
+    this.#deleteFault = fault;
+  }
+  setTransferLimit(limit) {
+    this.#transferLimit = limit;
+  }
+  maybeFault(path, phase) {
+    this.#writeFault?.(path, phase);
+  }
+  maybeDeleteFault(path) {
+    this.#deleteFault?.(path);
+  }
+  limitTransfer(path, operation, requestedBytes, at) {
+    const limited = this.#transferLimit?.(path, operation, requestedBytes, at) ?? requestedBytes;
+    if (!Number.isSafeInteger(limited) || limited < 0 || limited > requestedBytes) {
+      throw new RangeError(`Invalid test transfer limit ${String(limited)} for ${String(requestedBytes)} requested bytes`);
+    }
+    return limited;
+  }
+  readFileBytes(path) {
+    const node = this.#find(path);
+    return node?.kind === "file" ? node.bytes.slice() : void 0;
+  }
+  writeFileBytes(path, bytes) {
+    const segments = path.split("/").filter((segment) => segment.length > 0);
+    const name = segments.pop();
+    if (name === void 0)
+      throw new Error("A file path cannot be empty");
+    let directory = this.#rootNode;
+    for (const segment of segments) {
+      let child = directory.children.get(segment);
+      if (child === void 0) {
+        child = { kind: "directory", name: segment, children: /* @__PURE__ */ new Map() };
+        directory.children.set(segment, child);
+      }
+      if (child.kind !== "directory")
+        throw new Error(`Not a directory: ${segment}`);
+      directory = child;
+    }
+    const existing = directory.children.get(name);
+    if (existing?.kind === "directory")
+      throw new Error(`Not a file: ${path}`);
+    directory.children.set(name, {
+      kind: "file",
+      name,
+      bytes: bytes.slice(),
+      lockHolder: existing?.lockHolder ?? null
+    });
+  }
+  corruptFileByte(path, offset) {
+    const node = this.#find(path);
+    if (node?.kind !== "file")
+      throw new Error(`Not a file: ${path}`);
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset >= node.bytes.byteLength) {
+      throw new RangeError(`Invalid corruption offset ${String(offset)} for ${path}`);
+    }
+    node.bytes[offset] = (node.bytes[offset] ?? 0) ^ 255;
+  }
+  #find(path) {
+    let node = this.#rootNode;
+    for (const segment of path.split("/").filter((segment2) => segment2.length > 0)) {
+      if (node.kind !== "directory")
+        return void 0;
+      const child = node.children.get(segment);
+      if (child === void 0)
+        return void 0;
+      node = child;
+    }
+    return node;
+  }
 }
 function notFound(name) {
-    return new DOMException(`A requested file or directory could not be found: ${name}`, "NotFoundError");
+  return new DOMException(`A requested file or directory could not be found: ${name}`, "NotFoundError");
 }
 function typeMismatch(name) {
-    return new DOMException(`The path is not of the requested type: ${name}`, "TypeMismatchError");
+  return new DOMException(`The path is not of the requested type: ${name}`, "TypeMismatchError");
 }
 function locked(name) {
-    return new DOMException(`Access handles cannot be created if there is another open access handle: ${name}`, "NoModificationAllowedError");
+  return new DOMException(`Access handles cannot be created if there is another open access handle: ${name}`, "NoModificationAllowedError");
 }
 class ShimDirectoryHandle {
-    kind = "directory";
-    #shim;
-    #node;
-    #path;
-    constructor(shim, node, path) {
-        this.#shim = shim;
-        this.#node = node;
-        this.#path = path;
-    }
-    get name() {
-        return this.#node.name;
-    }
-    #childPath(name) {
-        return this.#path.length === 0 ? name : `${this.#path}/${name}`;
-    }
-    async getFileHandle(name, options) {
-        validateEntryName(name);
-        const existing = this.#node.children.get(name);
-        if (existing === undefined) {
-            if (options?.create !== true)
-                throw notFound(name);
-            this.#shim.maybeFault(this.#childPath(name), "create");
-            const node = { kind: "file", name, bytes: new Uint8Array(0), lockHolder: null };
-            this.#node.children.set(name, node);
-            return new ShimFileHandle(this.#shim, node, this.#childPath(name));
-        }
-        if (existing.kind !== "file")
-            throw typeMismatch(name);
-        return new ShimFileHandle(this.#shim, existing, this.#childPath(name));
-    }
-    async getDirectoryHandle(name, options) {
-        validateEntryName(name);
-        const existing = this.#node.children.get(name);
-        if (existing === undefined) {
-            if (options?.create !== true)
-                throw notFound(name);
-            this.#shim.maybeFault(this.#childPath(name), "create");
-            const node = { kind: "directory", name, children: new Map() };
-            this.#node.children.set(name, node);
-            return new ShimDirectoryHandle(this.#shim, node, this.#childPath(name));
-        }
-        if (existing.kind !== "directory")
-            throw typeMismatch(name);
-        return new ShimDirectoryHandle(this.#shim, existing, this.#childPath(name));
-    }
-    async removeEntry(name, options) {
-        validateEntryName(name);
-        const existing = this.#node.children.get(name);
-        if (existing === undefined)
-            throw notFound(name);
-        this.#shim.maybeDeleteFault(this.#childPath(name));
-        if (existing.kind === "file") {
-            if (existing.lockHolder !== null)
-                throw locked(name);
-        }
-        else if (options?.recursive !== true) {
-            if (existing.children.size > 0) {
-                throw new DOMException(`The directory is not empty: ${name}`, "InvalidModificationError");
-            }
-        }
-        else {
-            assertSubtreeUnlocked(existing, name);
-        }
-        this.#node.children.delete(name);
-    }
-    async isSameEntry(other) {
-        return other instanceof ShimDirectoryHandle && other.#node === this.#node;
-    }
-    async resolve() {
-        return null;
-    }
-    async *entries() {
-        // Snapshot first: callers may mutate while iterating, as with the real API.
-        for (const [name, node] of [...this.#node.children.entries()]) {
-            if (this.#node.children.get(name) !== node)
-                continue;
-            yield [
-                name,
-                node.kind === "file"
-                    ? new ShimFileHandle(this.#shim, node, this.#childPath(name))
-                    : new ShimDirectoryHandle(this.#shim, node, this.#childPath(name)),
-            ];
-        }
-    }
-    async *keys() {
-        for await (const [name] of this.entries())
-            yield name;
-    }
-    async *values() {
-        for await (const [, handle] of this.entries())
-            yield handle;
-    }
-    [Symbol.asyncIterator]() {
-        return this.entries();
-    }
+  kind = "directory";
+  #shim;
+  #node;
+  #path;
+  constructor(shim, node, path) {
+    this.#shim = shim;
+    this.#node = node;
+    this.#path = path;
+  }
+  get name() {
+    return this.#node.name;
+  }
+  #childPath(name) {
+    return this.#path.length === 0 ? name : `${this.#path}/${name}`;
+  }
+  async getFileHandle(name, options) {
+    validateEntryName(name);
+    const existing = this.#node.children.get(name);
+    if (existing === void 0) {
+      if (options?.create !== true)
+        throw notFound(name);
+      this.#shim.maybeFault(this.#childPath(name), "create");
+      const node = { kind: "file", name, bytes: new Uint8Array(0), lockHolder: null };
+      this.#node.children.set(name, node);
+      return new ShimFileHandle(this.#shim, node, this.#childPath(name));
+    }
+    if (existing.kind !== "file")
+      throw typeMismatch(name);
+    return new ShimFileHandle(this.#shim, existing, this.#childPath(name));
+  }
+  async getDirectoryHandle(name, options) {
+    validateEntryName(name);
+    const existing = this.#node.children.get(name);
+    if (existing === void 0) {
+      if (options?.create !== true)
+        throw notFound(name);
+      this.#shim.maybeFault(this.#childPath(name), "create");
+      const node = { kind: "directory", name, children: /* @__PURE__ */ new Map() };
+      this.#node.children.set(name, node);
+      return new ShimDirectoryHandle(this.#shim, node, this.#childPath(name));
+    }
+    if (existing.kind !== "directory")
+      throw typeMismatch(name);
+    return new ShimDirectoryHandle(this.#shim, existing, this.#childPath(name));
+  }
+  async removeEntry(name, options) {
+    validateEntryName(name);
+    const existing = this.#node.children.get(name);
+    if (existing === void 0)
+      throw notFound(name);
+    this.#shim.maybeDeleteFault(this.#childPath(name));
+    if (existing.kind === "file") {
+      if (existing.lockHolder !== null)
+        throw locked(name);
+    } else if (options?.recursive !== true) {
+      if (existing.children.size > 0) {
+        throw new DOMException(`The directory is not empty: ${name}`, "InvalidModificationError");
+      }
+    } else {
+      assertSubtreeUnlocked(existing, name);
+    }
+    this.#node.children.delete(name);
+  }
+  async isSameEntry(other) {
+    return other instanceof ShimDirectoryHandle && other.#node === this.#node;
+  }
+  async resolve() {
+    return null;
+  }
+  async *entries() {
+    for (const [name, node] of [...this.#node.children.entries()]) {
+      if (this.#node.children.get(name) !== node)
+        continue;
+      yield [
+        name,
+        node.kind === "file" ? new ShimFileHandle(this.#shim, node, this.#childPath(name)) : new ShimDirectoryHandle(this.#shim, node, this.#childPath(name))
+      ];
+    }
+  }
+  async *keys() {
+    for await (const [name] of this.entries())
+      yield name;
+  }
+  async *values() {
+    for await (const [, handle] of this.entries())
+      yield handle;
+  }
+  [Symbol.asyncIterator]() {
+    return this.entries();
+  }
 }
 function assertSubtreeUnlocked(node, name) {
-    for (const child of node.children.values()) {
-        if (child.kind === "file") {
-            if (child.lockHolder !== null)
-                throw locked(`${name}/${child.name}`);
-        }
-        else {
-            assertSubtreeUnlocked(child, `${name}/${child.name}`);
-        }
-    }
+  for (const child of node.children.values()) {
+    if (child.kind === "file") {
+      if (child.lockHolder !== null)
+        throw locked(`${name}/${child.name}`);
+    } else {
+      assertSubtreeUnlocked(child, `${name}/${child.name}`);
+    }
+  }
 }
 function validateEntryName(name) {
-    if (name.length === 0 || name === "." || name === ".." || name.includes("/")) {
-        throw new TypeError(`Entry name is invalid: ${name}`);
-    }
+  if (name.length === 0 || name === "." || name === ".." || name.includes("/")) {
+    throw new TypeError(`Entry name is invalid: ${name}`);
+  }
 }
 class ShimFileHandle {
-    kind = "file";
-    #shim;
-    #node;
-    #path;
-    constructor(shim, node, path) {
-        this.#shim = shim;
-        this.#node = node;
-        this.#path = path;
-    }
-    get name() {
-        return this.#node.name;
-    }
-    async getFile() {
-        if (this.#node.lockHolder !== null)
-            throw locked(this.#node.name);
-        return new File([this.#node.bytes.slice()], this.#node.name);
-    }
-    async createSyncAccessHandle() {
-        if (this.#node.lockHolder !== null)
-            throw locked(this.#node.name);
-        const handle = new ShimSyncAccessHandle(this.#shim, this.#node, this.#path);
-        this.#node.lockHolder = handle;
-        return handle;
-    }
-    async isSameEntry(other) {
-        return other instanceof ShimFileHandle && other.#node === this.#node;
-    }
+  kind = "file";
+  #shim;
+  #node;
+  #path;
+  constructor(shim, node, path) {
+    this.#shim = shim;
+    this.#node = node;
+    this.#path = path;
+  }
+  get name() {
+    return this.#node.name;
+  }
+  async getFile() {
+    if (this.#node.lockHolder !== null)
+      throw locked(this.#node.name);
+    return new File([this.#node.bytes.slice()], this.#node.name);
+  }
+  async createSyncAccessHandle() {
+    if (this.#node.lockHolder !== null)
+      throw locked(this.#node.name);
+    const handle = new ShimSyncAccessHandle(this.#shim, this.#node, this.#path);
+    this.#node.lockHolder = handle;
+    return handle;
+  }
+  async isSameEntry(other) {
+    return other instanceof ShimFileHandle && other.#node === this.#node;
+  }
 }
 class ShimSyncAccessHandle {
-    #shim;
-    #node;
-    #path;
-    #closed = false;
-    constructor(shim, node, path) {
-        this.#shim = shim;
-        this.#node = node;
-        this.#path = path;
-    }
-    #assertOpen() {
-        if (this.#closed) {
-            throw new DOMException("The access handle is closed", "InvalidStateError");
-        }
-    }
-    getSize() {
-        this.#assertOpen();
-        return this.#node.bytes.byteLength;
-    }
-    read(buffer, options) {
-        this.#assertOpen();
-        const at = options?.at ?? 0;
-        const target = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        const limit = this.#shim.limitTransfer(this.#path, "read", target.byteLength, at);
-        const source = this.#node.bytes.subarray(at, at + limit);
-        target.set(source);
-        return source.byteLength;
-    }
-    write(buffer, options) {
-        this.#assertOpen();
-        this.#shim.maybeFault(this.#path, "write");
-        const at = options?.at ?? 0;
-        const requested = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        const limit = this.#shim.limitTransfer(this.#path, "write", requested.byteLength, at);
-        const source = requested.subarray(0, limit);
-        const end = at + source.byteLength;
-        if (source.byteLength > 0 && end > this.#node.bytes.byteLength) {
-            const grown = new Uint8Array(end);
-            grown.set(this.#node.bytes);
-            this.#node.bytes = grown;
-        }
-        this.#node.bytes.set(source, at);
-        return source.byteLength;
-    }
-    truncate(size) {
-        this.#assertOpen();
-        this.#shim.maybeFault(this.#path, "write");
-        if (size <= this.#node.bytes.byteLength) {
-            this.#node.bytes = this.#node.bytes.slice(0, size);
-            return;
-        }
-        const grown = new Uint8Array(size);
-        grown.set(this.#node.bytes);
-        this.#node.bytes = grown;
-    }
-    flush() {
-        this.#assertOpen();
-        this.#shim.maybeFault(this.#path, "flush");
-    }
-    close() {
-        if (this.#closed)
-            return;
-        this.#closed = true;
-        if (this.#node.lockHolder === this)
-            this.#node.lockHolder = null;
-    }
+  #shim;
+  #node;
+  #path;
+  #closed = false;
+  constructor(shim, node, path) {
+    this.#shim = shim;
+    this.#node = node;
+    this.#path = path;
+  }
+  #assertOpen() {
+    if (this.#closed) {
+      throw new DOMException("The access handle is closed", "InvalidStateError");
+    }
+  }
+  getSize() {
+    this.#assertOpen();
+    return this.#node.bytes.byteLength;
+  }
+  read(buffer, options) {
+    this.#assertOpen();
+    const at = options?.at ?? 0;
+    const target = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const limit = this.#shim.limitTransfer(this.#path, "read", target.byteLength, at);
+    const source = this.#node.bytes.subarray(at, at + limit);
+    target.set(source);
+    return source.byteLength;
+  }
+  write(buffer, options) {
+    this.#assertOpen();
+    this.#shim.maybeFault(this.#path, "write");
+    const at = options?.at ?? 0;
+    const requested = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const limit = this.#shim.limitTransfer(this.#path, "write", requested.byteLength, at);
+    const source = requested.subarray(0, limit);
+    const end = at + source.byteLength;
+    if (source.byteLength > 0 && end > this.#node.bytes.byteLength) {
+      const grown = new Uint8Array(end);
+      grown.set(this.#node.bytes);
+      this.#node.bytes = grown;
+    }
+    this.#node.bytes.set(source, at);
+    return source.byteLength;
+  }
+  truncate(size) {
+    this.#assertOpen();
+    this.#shim.maybeFault(this.#path, "write");
+    if (size <= this.#node.bytes.byteLength) {
+      this.#node.bytes = this.#node.bytes.slice(0, size);
+      return;
+    }
+    const grown = new Uint8Array(size);
+    grown.set(this.#node.bytes);
+    this.#node.bytes = grown;
+  }
+  flush() {
+    this.#assertOpen();
+    this.#shim.maybeFault(this.#path, "flush");
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    if (this.#node.lockHolder === this)
+      this.#node.lockHolder = null;
+  }
 }
+export {
+  MemoryOpfs
+};