Initial implementation

Author: viktor-podzigun

.gitignore

@@ -0,0 +1,7 @@
+*.log
+package-lock.json
+bun.lockb
+
+.idea/
+dist/
+node_modules/

LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 FAR.js contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,9 @@
+
+[![CI](https://github.com/farjs/better-sqlite3-websql/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/farjs/better-sqlite3-websql/actions/workflows/ci.yml?query=workflow%3Aci+branch%3Amain)
+[![npm version](https://img.shields.io/npm/v/@farjs/better-sqlite3-websql)](https://www.npmjs.com/package/@farjs/better-sqlite3-websql)
+
+## @farjs/better-sqlite3-websql
+
+Cross-runtime implementation of [WebSql](https://www.npmjs.com/package/websql) api
+backed by [better-sqlite3](https://github.com/WiseLibs/better-sqlite3)
+and [bun:sqlite](https://bun.sh/docs/api/sqlite).

SQLiteDatabase.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const Database = require("@farjs/better-sqlite3-wrapper");
+const SQLiteResult = require('@expo/websql/lib/sqlite/SQLiteResult');
+
+const READ_ONLY_ERROR = new Error('could not prepare statement (23 not authorized)');
+  
+function SQLiteDatabase(name) {
+    const db = new Database(name);
+    db.pragma('journal_mode = WAL');
+    db._lastInsertRowIdQuery = db.prepare("SELECT last_insert_rowid() AS id;");
+    db._changesQuery = db.prepare("SELECT changes() AS changes;");
+    this._db = db;
+}
+
+function runSelect(db, sql, args, cb) {
+    let err;
+    let resultSet;
+    try {
+        const rows = db.prepare(sql).all(args);
+        
+        const insertId = undefined;
+        const rowsAffected = 0;
+        resultSet = new SQLiteResult(null, insertId, rowsAffected, rows);
+    }
+    catch (e) {
+        err = e;
+    }
+
+    if (err) {
+        return cb(new SQLiteResult(err));
+    }
+    cb(resultSet);
+}
+
+function runNonSelect(db, sql, args, cb) {
+    let err;
+    let resultSet;
+    try {
+        db.prepare(sql).run(args);
+
+        const insertId = db._lastInsertRowIdQuery.get().id;
+        const rowsAffected = db._changesQuery.get().changes;
+        const rows = [];
+        resultSet = new SQLiteResult(null, insertId, rowsAffected, rows);
+    }
+    catch (e) {
+        err = e;
+    }
+
+    if (err) {
+        return cb(new SQLiteResult(err));
+    }
+    cb(resultSet);
+}
+
+SQLiteDatabase.prototype.exec = function exec(queries, readOnly, callback) {
+    const db = this._db;
+    const len = queries.length;
+    const results = new Array(len);
+
+    var i = 0;
+
+    function checkDone() {
+        if (++i === len) {
+            callback(null, results);
+        } else {
+            doNext();
+        }
+    }
+
+    function onQueryComplete(i) {
+        return function (res) {
+            results[i] = res;
+            checkDone();
+        };
+    }
+
+    function doNext() {
+        const query = queries[i];
+        const sql = query.sql;
+        const args = query.args;
+
+        // We try to sniff whether it's a SELECT query or not.
+        // This is inherently error-prone, although it will probably work in the 99%
+        // case.
+        const isSelect = /^\s*SELECT\b/i.test(sql);
+
+        if (readOnly && !isSelect) {
+            onQueryComplete(i)(new SQLiteResult(READ_ONLY_ERROR));
+        } else if (isSelect) {
+            runSelect(db, sql, args, onQueryComplete(i));
+        } else {
+            runNonSelect(db, sql, args, onQueryComplete(i));
+        }
+    }
+
+    doNext();
+};
+
+module.exports = SQLiteDatabase;

index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const customOpenDatabase = require('@expo/websql/custom');
+const SQLiteDatabase = require('./SQLiteDatabase.js');
+
+const openDatabase = customOpenDatabase(SQLiteDatabase);
+
+module.exports = openDatabase;

index.test.js

@@ -0,0 +1,89 @@
+const openDatabase = require('./index');
+
+const assert = require('assert').strict;
+const it = function() {
+    return process['isBun'] ? test : require('node:test').it;
+}();
+
+//given
+const db = openDatabase(":memory:", '1.0', 'description', 1);
+
+it('should write to database', async () => {
+    //when
+    const result = await new Promise((resolve, reject) => {
+        db.transaction((tx) => {
+            tx.executeSql(`
+                create table test(
+                    id     integer primary key,
+                    name   text not null
+                );
+            `, [], (tx, r) => {
+                const insertSql = "insert into test (name) values (?);"
+                tx.executeSql(insertSql, ["test1"], (tx, r) => {
+                    tx.executeSql(insertSql, ["test2"], (tx, r) => {
+                        resolve(r);
+                    }, (tx, e) => {
+                        reject(e);
+                    });
+                }, (tx, e) => {
+                    reject(e);
+                });
+            }, (tx, e) => {
+                reject(e);
+            });
+        });
+
+    });
+
+    //then
+    assert.deepEqual(result.insertId, 2);
+    assert.deepEqual(result.rowsAffected, 1);
+    assert.deepEqual(result.rows._array, []);
+});
+
+it('should read all records from database', async () => {
+    //when
+    const result = await new Promise((resolve, reject) => {
+        db.readTransaction((tx) => {
+            tx.executeSql("select * from test order by id;", [], (tx, r) => {
+                resolve(r);
+            }, (tx, e) => {
+                reject(e);
+            });
+        });
+
+    });
+
+    //then
+    assert.deepEqual(result.insertId, undefined);
+    assert.deepEqual(result.rowsAffected, 0);
+    assert.deepEqual(result.rows._array, [{
+        id: 1,
+        name: "test1"
+    }, {
+        id: 2,
+        name: "test2"
+    }]);
+});
+
+it('should read record by id from database', async () => {
+    //when
+    const result = await new Promise((resolve, reject) => {
+        db.readTransaction((tx) => {
+            tx.executeSql("select * from test where id=?;", [2], (tx, r) => {
+                resolve(r);
+            }, (tx, e) => {
+                reject(e);
+            });
+        });
+
+    });
+
+    //then
+    assert.deepEqual(result.insertId, undefined);
+    assert.deepEqual(result.rowsAffected, 0);
+    assert.deepEqual(result.rows._array, [{
+        id: 2,
+        name: "test2"
+    }]);
+});

package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@farjs/better-sqlite3-websql",
+  "version": "0.0.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/farjs/better-sqlite3-websql.git"
+  },
+  "author": "viktor-podzigun",
+  "private": false,
+  "description": "Cross-runtime implementation of WebSql api backed by better-sqlite3 and bun:sqlite",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/farjs/better-sqlite3-websql/issues"
+  },
+  "homepage": "https://github.com/farjs/better-sqlite3-websql",
+  "keywords": [
+    "sqlite",
+    "cross-runtime",
+    "bun"
+  ],
+  "files": [
+    "index.js",
+    "SQLiteDatabase.js",
+    "LICENSE.txt",
+    "README.md"
+  ],
+  "main": "./index.js",
+  "exports": "./index.js",
+  "browserslist": "maintained node versions",
+  "engines": {
+    "node": ">=14.21.1",
+    "bun": ">=0.5.8"
+  },
+  "dependencies": {
+    "@expo/websql": "^1.0.1",
+    "@farjs/better-sqlite3-wrapper": "../better-sqlite3-wrapper"
+  }
+}