Merge branch 'main' into node

Author: tomayac

README.md

@@ -20,41 +20,71 @@ npm install @sqlite.org/sqlite-wasm
 
 ## Usage
 
-There are two ways to use SQLite Wasm:
-[in the main thread](#in-the-main-thread-without-opfs) and
-[in a worker](#in-a-worker-with-opfs-if-available). Only the worker version
-allows you to use the origin private file system (OPFS) storage back-end.
+There are three ways to use SQLite Wasm:
 
-### In the main thread (without OPFS):
+- [in the main thread with a wrapped worker](#in-a-wrapped-worker-with-opfs-if-available)
+  (🏆 preferred option)
+- [in a worker](#in-a-worker-with-opfs-if-available)
+- [in the main thread](#in-the-main-thread-without-opfs)
+
+Only the worker versions allow you to use the origin private file system (OPFS)
+storage back-end.
+
+### In a wrapped worker (with OPFS if available):
+
+> **Warning**
+>
+> For this to work, you need to set the following headers on your server:
+>
+> `Cross-Origin-Opener-Policy: same-origin`
+>
+> `Cross-Origin-Embedder-Policy: require-corp`
 
 ```js
-import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+import { sqlite3Worker1Promiser } from '@sqlite.org/sqlite-wasm';
 
 const log = (...args) => console.log(...args);
 const error = (...args) => console.error(...args);
 
-const start = function (sqlite3) {
-  log('Running SQLite3 version', sqlite3.version.libVersion);
-  const db = new sqlite3.oo1.DB('/mydb.sqlite3', 'ct');
-  // Your SQLite code here.
-};
-
-log('Loading and initializing SQLite3 module...');
-sqlite3InitModule({
-  print: log,
-  printErr: error,
-}).then((sqlite3) => {
+(async () => {
   try {
+    log('Loading and initializing SQLite3 module...');
+
+    const promiser = await new Promise((resolve) => {
+      const _promiser = sqlite3Worker1Promiser({
+        onready: () => {
+          resolve(_promiser);
+        },
+      });
+    });
+
     log('Done initializing. Running demo...');
-    start(sqlite3);
+
+    let response;
+
+    response = await promiser('config-get', {});
+    log('Running SQLite3 version', response.result.version.libVersion);
+
+    response = await promiser('open', {
+      filename: 'file:mydb.sqlite3?vfs=opfs',
+    });
+    const { dbId } = response;
+    log(
+      'OPFS is available, created persisted database at',
+      response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'),
+    );
+    // Your SQLite code here.
   } catch (err) {
+    if (!(err instanceof Error)) {
+      err = new Error(err.result.message);
+    }
     error(err.name, err.message);
   }
-});
+})();
 ```
 
-The `db` object above implements the
-[Object Oriented API #1](https://sqlite.org/wasm/doc/trunk/api-oo1.md).
+The `promiser` object above implements the
+[Worker1 API](https://sqlite.org/wasm/doc/trunk/api-worker1.md#worker1-methods).
 
 ### In a worker (with OPFS if available):
 
@@ -105,6 +135,40 @@ sqlite3InitModule({
 });
 ```
 
+The `db` object above implements the
+[Object Oriented API #1](https://sqlite.org/wasm/doc/trunk/api-oo1.md).
+
+### In the main thread (without OPFS):
+
+```js
+import sqlite3InitModule from '@sqlite.org/sqlite-wasm';
+
+const log = (...args) => console.log(...args);
+const error = (...args) => console.error(...args);
+
+const start = function (sqlite3) {
+  log('Running SQLite3 version', sqlite3.version.libVersion);
+  const db = new sqlite3.oo1.DB('/mydb.sqlite3', 'ct');
+  // Your SQLite code here.
+};
+
+log('Loading and initializing SQLite3 module...');
+sqlite3InitModule({
+  print: log,
+  printErr: error,
+}).then((sqlite3) => {
+  try {
+    log('Done initializing. Running demo...');
+    start(sqlite3);
+  } catch (err) {
+    error(err.name, err.message);
+  }
+});
+```
+
+The `db` object above implements the
+[Object Oriented API #1](https://sqlite.org/wasm/doc/trunk/api-oo1.md).
+
 ## Usage with vite
 
 If you are using [vite](https://vitejs.dev/), you need to add the following

bin/index.js

@@ -1,14 +1,20 @@
 import fs from 'fs';
 import fetch from 'node-fetch';
-import * as cheerio from 'cheerio';
 import decompress from 'decompress';
 
 async function getSqliteWasmDownloadLink() {
   const response = await fetch('https://sqlite.org/download.html');
   const html = await response.text();
-  const $ = cheerio.load(html);
-  const fileName = $('a[name="wasm"]').closest('tr').next().find('a').text();
-  const sqliteWasmLink = `https://sqlite.org/${new Date().getFullYear()}/${fileName}`;
+  const sqliteWasmLink =
+    'https://sqlite.org/' +
+    html
+      .replace(
+        /^.*?<!-- Download product data for scripts to read(.*?)-->.*?$/gms,
+        '$1',
+      )
+      .split(/\n/)
+      .filter((row) => /sqlite-wasm/.test(row))[0]
+      .split(/,/)[2];
   console.log(`Found SQLite Wasm download link: ${sqliteWasmLink}`);
   return sqliteWasmLink;
 }
@@ -19,6 +25,11 @@ async function downloadAndUnzipSqliteWasm(sqliteWasmDownloadLink) {
   }
   console.log('Downloading and unzipping SQLite Wasm...');
   const response = await fetch(sqliteWasmDownloadLink);
+  if (!response.ok || response.status !== 200) {
+    throw new Error(
+      `Unable to download SQLite Wasm from ${sqliteWasmDownloadLink}`,
+    );
+  }
   const buffer = await response.arrayBuffer();
   fs.writeFileSync('sqlite-wasm.zip', Buffer.from(buffer));
   const files = await decompress('sqlite-wasm.zip', 'sqlite-wasm', {
@@ -35,9 +46,9 @@ async function downloadAndUnzipSqliteWasm(sqliteWasmDownloadLink) {
 }
 
 async function main() {
-  const sqliteWasmLink = await getSqliteWasmDownloadLink();
-  await downloadAndUnzipSqliteWasm(sqliteWasmLink);
   try {
+    const sqliteWasmLink = await getSqliteWasmDownloadLink();
+    await downloadAndUnzipSqliteWasm(sqliteWasmLink);
     fs.copyFileSync(
       './node_modules/module-workers-polyfill/module-workers-polyfill.min.js',
       './demo/module-workers-polyfill.min.js',

demo/index.html

@@ -4,13 +4,16 @@
     <meta charset="utf-8" />
     <title>SQLite Wasm Demo</title>
     <script type="module" src="script.js"></script>
+    <script type="module" src="wrapped-worker.js"></script>
     <script type="module" src="main-thread.js"></script>
   </head>
   <body>
     <h1>SQLite Wasm Demo</h1>
-    <h2>Main thread</h2>
-    <div class="main-thread"></div>
+    <h2>Wrapped Worker</h2>
+    <div class="worker-promiser"></div>
     <h2>Worker</h2>
     <div class="worker"></div>
+    <h2>Main thread</h2>
+    <div class="main-thread"></div>
   </body>
 </html>

demo/wrapped-worker.js

@@ -0,0 +1,72 @@
+import { sqlite3Worker1Promiser } from '../index.mjs';
+
+(async () => {
+  const container = document.querySelector('.worker-promiser');
+
+  const logHtml = function (cssClass, ...args) {
+    const div = document.createElement('div');
+    if (cssClass) div.classList.add(cssClass);
+    div.append(document.createTextNode(args.join(' ')));
+    container.append(div);
+  };
+
+  try {
+    logHtml('', 'Loading and initializing SQLite3 module...');
+
+    const promiser = await new Promise((resolve) => {
+      const _promiser = sqlite3Worker1Promiser({
+        onready: () => {
+          resolve(_promiser);
+        },
+      });
+    });
+
+    logHtml('', 'Done initializing. Running demo...');
+
+    let response;
+
+    response = await promiser('config-get', {});
+    logHtml('', 'Running SQLite3 version', response.result.version.libVersion);
+
+    response = await promiser('open', {
+      filename: 'file:worker-promiser.sqlite3?vfs=opfs',
+    });
+    const { dbId } = response;
+    logHtml(
+      '',
+      'OPFS is available, created persisted database at',
+      response.result.filename.replace(/^file:(.*?)\?vfs=opfs/, '$1'),
+    );
+
+    await promiser('exec', { dbId, sql: 'CREATE TABLE IF NOT EXISTS t(a,b)' });
+    logHtml('', 'Creating a table...');
+
+    logHtml('', 'Insert some data using exec()...');
+    for (let i = 20; i <= 25; ++i) {
+      await promiser('exec', {
+        dbId,
+        sql: 'INSERT INTO t(a,b) VALUES (?,?)',
+        bind: [i, i * 2],
+      });
+    }
+
+    logHtml('', 'Query data with exec()');
+    await promiser('exec', {
+      dbId,
+      sql: 'SELECT a FROM t ORDER BY a LIMIT 3',
+      callback: (result) => {
+        if (!result.row) {
+          return;
+        }
+        logHtml('', result.row);
+      },
+    });
+
+    await promiser('close', { dbId });
+  } catch (err) {
+    if (!(err instanceof Error)) {
+      err = new Error(err.result.message);
+    }
+    console.error(err.name, err.message);
+  }
+})();

index.d.ts

@@ -1887,6 +1887,14 @@ declare type Sqlite3Static = {
     DB: typeof Database;
   };
 
+  /** Version numbers */
+  version: {
+    libVersion: string;
+    libVersionNumber: number;
+    sourceId: string;
+    downloadVersion: number;
+  };
+
   /**
    * Initializes the Worker API.
    *

index.mjs

@@ -1,3 +1,7 @@
 import { default as sqlite3InitModule } from './sqlite-wasm/jswasm/sqlite3-bundler-friendly.mjs';
+import './sqlite-wasm/jswasm/sqlite3-worker1-promiser-bundler-friendly.js';
+
+const sqlite3Worker1Promiser = self.sqlite3Worker1Promiser;
 
 export default sqlite3InitModule;
+export { sqlite3Worker1Promiser };