@ehegnes/wa-sqlite 2.0.0-beta.0

package/src/examples/LazyLock.js

@@ -0,0 +1,90 @@
+import { Lock } from './Lock.js';
+
+export class LazyLock extends Lock {
+  #channel;
+  #isBusy = false;
+  #hasReleaseRequest = false;
+
+  /**
+   * @param {string} name 
+   */
+  constructor(name) {
+    super(name);
+    this.#channel = new BroadcastChannel(name);
+    this.#channel.onmessage = (event) => {
+      if (this.#isBusy) {
+        // We're using the lock so postpone the release.
+        this.#hasReleaseRequest = true;
+      } else {
+        this.release();
+      }
+    }
+  }
+
+  close() {
+    super.close();
+    this.#channel.onmessage = null;
+    this.#channel.close();
+  }
+
+  /**
+   * @param {LockMode} mode 
+   * @param {number} timeout 
+   * @returns {Promise<boolean>}
+   */
+  async acquire(mode, timeout = -1) {
+    this.#isBusy = true;
+    try {
+      if (mode === this.mode) {
+        // We never had to release the lock.
+        return true;
+      }
+
+      if (this.mode) {
+        // Release the lock to acquire it in a different mode.
+        super.release();
+      } else {
+        // Poll for the lock. This isn't necessary but if it works it avoids
+        // the BroadcastChannel traffic.
+        if (await super.acquire(mode, 0)) {
+          return true;
+        }
+      }
+
+      // Request the lock.
+      const pResult = super.acquire(mode, timeout)
+      this.#channel.postMessage({});
+
+      return await pResult;
+    } catch (e) {
+      this.release();
+      throw e;
+    }
+  }
+
+  /**
+   * @param {LockMode} mode 
+   * @returns {boolean}
+   */
+  acquireIfHeld(mode) {
+    if (mode === this.mode) {
+      this.#isBusy = true;
+      return true;
+    }
+    return false;
+  }
+
+  release() {
+    super.release();
+    this.#isBusy = false;
+    this.#hasReleaseRequest = false;
+  }
+
+  releaseLazy() {
+    // Release the lock only if someone else wants it.
+    this.#isBusy = false;
+    if (this.#hasReleaseRequest) {
+      this.release();
+    }
+  }
+}

package/src/examples/Lock.js

@@ -0,0 +1,69 @@
+// This is a convenience wrapper for the Web Locks API.
+export class Lock {
+  #name;
+  /** @type {LockMode?} */ #mode = null;
+  /** @type {Promise<Function|null>} */ #releaser = Promise.resolve(null);
+  #isAcquiring = false;
+
+  /**
+   * @param {string} name 
+   */
+  constructor(name) {
+    this.#name = name;
+  }
+
+  get name() { return this.#name; }
+  get mode() { return this.#mode; }
+
+  close() {
+    this.release();
+  }
+  
+  /**
+   * @param {'shared'|'exclusive'} mode 
+   * @param {number} timeout -1 for infinite, 0 for poll, >0 for milliseconds
+   * @return {Promise<boolean>} true if lock acquired, false on failed poll
+   */
+  async acquire(mode, timeout = -1) {
+    if (this.#isAcquiring) throw new Error('Lock is already being acquired');
+    this.#isAcquiring = true;
+    try {
+      if (this.#mode) {
+        throw new Error(`Lock ${this.#name} is already acquired`);
+      }
+
+      this.#releaser = new Promise((resolve, reject) => {
+        /** @type {LockOptions} */
+        const options = { mode, ifAvailable: timeout === 0 };
+        if (timeout > 0) {
+          options.signal = AbortSignal.timeout(timeout);
+        }
+
+        navigator.locks.request(this.#name, options, lock => {
+          if (lock === null) {
+            // Polling (with timeout = 0) did not acquire the lock.
+            return resolve(null);
+          }
+
+          // Lock acquired. The lock is released when this returned
+          // Promise is resolved.
+          this.#mode = mode;
+          return new Promise(releaser => {
+            resolve(releaser);
+          })
+        }).catch(e => {
+          return reject(e);
+        });
+      });
+
+      return this.#releaser.then(releaser => !!releaser)
+    } finally {
+      this.#isAcquiring = false;
+    }
+  }
+
+  release() {
+    this.#releaser.then(releaser => releaser?.(), () => {});
+    this.#mode = null;
+  }
+}

package/src/examples/MemoryAsyncVFS.js

@@ -0,0 +1,100 @@
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+import { MemoryVFS } from './MemoryVFS.js';
+
+// Sample asynchronous in-memory filesystem. This filesystem requires an
+// asynchronous WebAssembly build (Asyncify or JSPI).
+export class MemoryAsyncVFS extends MemoryVFS {
+
+  static async create(name, module) {
+    const vfs = new MemoryVFS(name, module);
+    await vfs.isReady();
+    return vfs;
+  }
+
+  constructor(name, module) {
+    super(name, module);
+  }
+
+  async close() {
+    for (const fileId of this.mapIdToFile.keys()) {
+      await this.xClose(fileId);
+    }
+  }
+
+  /**
+   * @param {string?} name 
+   * @param {number} fileId 
+   * @param {number} flags 
+   * @param {DataView} pOutFlags 
+   * @returns {Promise<number>}
+   */
+  async jOpen(name, fileId, flags, pOutFlags) {
+    return super.jOpen(name, fileId, flags, pOutFlags);
+  }
+
+  /**
+   * @param {number} fileId 
+   * @returns {Promise<number>}
+   */
+  async jClose(fileId) {
+    return super.jClose(fileId);
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {Promise<number>}
+   */
+  async jRead(fileId, pData, iOffset) {
+    return super.jRead(fileId, pData, iOffset);
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {Promise<number>}
+   */
+  async jWrite(fileId, pData, iOffset) {
+    return super.jWrite(fileId, pData, iOffset);
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {number} iSize 
+   * @returns {Promise<number>}
+   */
+  async xTruncate(fileId, iSize) {
+    return super.jTruncate(fileId, iSize);
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {DataView} pSize64 
+   * @returns {Promise<number>}
+   */
+  async jFileSize(fileId, pSize64) {
+    return super.jFileSize(fileId, pSize64);
+  }
+
+  /**
+   * 
+   * @param {string} name 
+   * @param {number} syncDir 
+   * @returns {Promise<number>}
+   */
+  async jDelete(name, syncDir) {
+    return super.jDelete(name, syncDir);
+  }
+
+  /**
+   * @param {string} name 
+   * @param {number} flags 
+   * @param {DataView} pResOut 
+   * @returns {Promise<number>}
+   */
+  async jAccess(name, flags, pResOut) {
+    return super.jAccess(name, flags, pResOut);
+  }
+}

package/src/examples/MemoryVFS.js

@@ -0,0 +1,176 @@
+// Copyright 2024 Roy T. Hashimoto. All Rights Reserved.
+import { FacadeVFS } from '../FacadeVFS.js';
+import * as VFS from '../VFS.js';
+
+// Sample in-memory filesystem.
+export class MemoryVFS extends FacadeVFS {
+  // Map of existing files, keyed by filename.
+  mapNameToFile = new Map();
+
+  // Map of open files, keyed by id (sqlite3_file pointer).
+  mapIdToFile = new Map();
+
+  static async create(name, module) {
+    const vfs = new MemoryVFS(name, module);
+    await vfs.isReady();
+    return vfs;
+  }
+
+  constructor(name, module) {
+    super(name, module);
+  }
+
+  close() {
+    for (const fileId of this.mapIdToFile.keys()) {
+      this.jClose(fileId);
+    }
+  }
+
+  /**
+   * @param {string?} filename 
+   * @param {number} fileId 
+   * @param {number} flags 
+   * @param {DataView} pOutFlags 
+   * @returns {number|Promise<number>}
+   */
+  jOpen(filename, fileId, flags, pOutFlags) {
+    const url = new URL(filename || Math.random().toString(36).slice(2), 'file://');
+    const pathname = url.pathname;
+
+    let file = this.mapNameToFile.get(pathname);
+    if (!file) {
+      if (flags & VFS.SQLITE_OPEN_CREATE) {
+        // Create a new file object.
+        file = {
+          pathname,
+          flags,
+          size: 0,
+          data: new ArrayBuffer(0)
+        };
+        this.mapNameToFile.set(pathname, file);
+      } else {
+        return VFS.SQLITE_CANTOPEN;
+      }
+    }
+
+    // Put the file in the opened files map.
+    this.mapIdToFile.set(fileId, file);
+    pOutFlags.setInt32(0, flags, true);
+    return VFS.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @returns {number|Promise<number>}
+   */
+  jClose(fileId) {
+    const file = this.mapIdToFile.get(fileId);
+    this.mapIdToFile.delete(fileId);
+
+    if (file.flags & VFS.SQLITE_OPEN_DELETEONCLOSE) {
+      this.mapNameToFile.delete(file.pathname);
+    }
+    return VFS.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number|Promise<number>}
+   */
+  jRead(fileId, pData, iOffset) {
+    const file = this.mapIdToFile.get(fileId);
+
+    // Clip the requested read to the file boundary.
+    const bgn = Math.min(iOffset, file.size);
+    const end = Math.min(iOffset + pData.byteLength, file.size);
+    const nBytes = end - bgn;
+
+    if (nBytes) {
+      pData.set(new Uint8Array(file.data, bgn, nBytes));
+    }
+
+    if (nBytes < pData.byteLength) {
+      // Zero unused area of read buffer.
+      pData.fill(0, nBytes);
+      return VFS.SQLITE_IOERR_SHORT_READ;
+    }
+    return VFS.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {Uint8Array} pData 
+   * @param {number} iOffset
+   * @returns {number|Promise<number>}
+   */
+  jWrite(fileId, pData, iOffset) {
+    const file = this.mapIdToFile.get(fileId);
+    if (iOffset + pData.byteLength > file.data.byteLength) {
+      // Resize the ArrayBuffer to hold more data.
+      const newSize = Math.max(iOffset + pData.byteLength, 2 * file.data.byteLength);
+      const data = new ArrayBuffer(newSize);
+      new Uint8Array(data).set(new Uint8Array(file.data, 0, file.size));
+      file.data = data;
+    }
+
+    // Copy data.
+    new Uint8Array(file.data, iOffset, pData.byteLength).set(pData.subarray());
+    file.size = Math.max(file.size, iOffset + pData.byteLength);
+    return VFS.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {number} iSize 
+   * @returns {number|Promise<number>}
+   */
+  jTruncate(fileId, iSize) {
+    const file = this.mapIdToFile.get(fileId);
+
+    // For simplicity we don't make the ArrayBuffer smaller.
+    file.size = Math.min(file.size, iSize);
+    return VFS.SQLITE_OK;
+  }
+
+  /**
+   * @param {number} fileId 
+   * @param {DataView} pSize64 
+   * @returns {number|Promise<number>}
+   */
+  jFileSize(fileId, pSize64) {
+    const file = this.mapIdToFile.get(fileId);
+
+    pSize64.setBigInt64(0, BigInt(file.size), true);
+    return VFS.SQLITE_OK;
+  }
+
+  /**
+   * @param {string} name 
+   * @param {number} syncDir 
+   * @returns {number|Promise<number>}
+   */
+  jDelete(name, syncDir) {
+    const url = new URL(name, 'file://');
+    const pathname = url.pathname;
+
+    this.mapNameToFile.delete(pathname);
+    return VFS.SQLITE_OK;
+  }
+
+  /**
+   * @param {string} name 
+   * @param {number} flags 
+   * @param {DataView} pResOut 
+   * @returns {number|Promise<number>}
+   */
+  jAccess(name, flags, pResOut) {
+    const url = new URL(name, 'file://');
+    const pathname = url.pathname;
+
+    const file = this.mapNameToFile.get(pathname);
+    pResOut.setInt32(0, file ? 1 : 0, true);
+    return VFS.SQLITE_OK;
+  }
+}