@rljson/io-sqlite-node 1.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rljson
+
+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.

package/README.architecture.md

@@ -0,0 +1,9 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Architecture

package/README.blog.md

@@ -0,0 +1,11 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Blog
+
+Add latest posts at the end.

package/README.contributors.md

@@ -0,0 +1,32 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Contributors Guide
+
+- [Prepare](#prepare)
+- [Develop](#develop)
+- [Administrate](#administrate)
+- [Fast Coding](#fast-coding)
+
+## Prepare
+
+Read [prepare.md](doc/prepare.md)
+
+<!-- ........................................................................-->
+
+## Develop
+
+Read [develop.md](doc/develop.md)
+
+## Administrate
+
+Read [create-new-repo.md](doc/create-new-repo.md)
+
+## Fast Coding
+
+Read [fast-coding-guide.md](doc/fast-coding-guide.md)

package/README.md

@@ -0,0 +1,24 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# @rljson/io-sqlite
+
+## Users
+
+| File                                 | Purpose                     |
+| ------------------------------------ | --------------------------- |
+| [README.public.md](README.public.md) | Install and use the package |
+
+## Contributors
+
+| File                                             | Purpose                       |
+| ------------------------------------------------ | ----------------------------- |
+| [README.contributors.md](README.contributors.md) | Run, debug, build and publish |
+| [README.architecture.md](README.architecture.md) | Software architecture guide   |
+| [README.trouble.md](README.trouble.md)           | Errors & solutions            |
+| [README.blog.md](README.blog.md)                 | Blog                          |

package/README.piano.md

@@ -0,0 +1,42 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Coding like a pianist
+
+Tricks and tips for high performance coders
+
+## Content <!-- omit in toc -->
+
+- [Vscode](#vscode)
+  - [Quick open files](#quick-open-files)
+  - [Multi cursor search and replace](#multi-cursor-search-and-replace)
+
+## Vscode
+
+### Quick open files
+
+❌ Don't open files by clicking through the folder hierarchy.
+
+✅ Quick open files by pressing `Cmd+Shift+P`, entering fragments of the
+file name and pressing `enter`.
+
+### Multi cursor search and replace
+
+❌ Don't use `Cmd+F` to search and replace files
+
+✅ Double click a word to be searched and replaced
+
+Press `Ctrl+ddd...` to create a multi cursor on all occurrences of the word
+
+Modify the word
+
+Press `ESC` to finish multi cursor edit
+
+When doing this the first time, search will not be case sensitive
+
+Press `Cmd+F`, click `Aa` to make `Ctrl+d` multi case sensitive

package/README.public.md

@@ -0,0 +1,15 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# @rljson/io-sqlite
+
+Todo: Add description here
+
+## Example
+
+[src/example.ts](src/example.ts)

package/README.trouble.md

@@ -0,0 +1,23 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Trouble shooting
+
+## Table of contents <!-- omit in toc -->
+
+- [Vscode Windows: Debugging is not working](#vscode-windows-debugging-is-not-working)
+
+## Vscode Windows: Debugging is not working
+
+Date: 2025-03-08
+
+⚠️ IMPORTANT: On Windows, please check out the repo on drive C. There is a bug
+in the VS Code Vitest extension (v1.14.4), which prevents test debugging from
+working: <https://github.com/vitest-dev/vscode/issues/548> Please check from
+time to time if the issue has been fixed and remove this note once it is
+resolved.

package/dist/README.architecture.md

@@ -0,0 +1,9 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Architecture

package/dist/README.blog.md

@@ -0,0 +1,11 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Blog
+
+Add latest posts at the end.

package/dist/README.contributors.md

@@ -0,0 +1,32 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Contributors Guide
+
+- [Prepare](#prepare)
+- [Develop](#develop)
+- [Administrate](#administrate)
+- [Fast Coding](#fast-coding)
+
+## Prepare
+
+Read [prepare.md](doc/prepare.md)
+
+<!-- ........................................................................-->
+
+## Develop
+
+Read [develop.md](doc/develop.md)
+
+## Administrate
+
+Read [create-new-repo.md](doc/create-new-repo.md)
+
+## Fast Coding
+
+Read [fast-coding-guide.md](doc/fast-coding-guide.md)

package/dist/README.md

@@ -0,0 +1,24 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# @rljson/io-sqlite
+
+## Users
+
+| File                                 | Purpose                     |
+| ------------------------------------ | --------------------------- |
+| [README.public.md](README.public.md) | Install and use the package |
+
+## Contributors
+
+| File                                             | Purpose                       |
+| ------------------------------------------------ | ----------------------------- |
+| [README.contributors.md](README.contributors.md) | Run, debug, build and publish |
+| [README.architecture.md](README.architecture.md) | Software architecture guide   |
+| [README.trouble.md](README.trouble.md)           | Errors & solutions            |
+| [README.blog.md](README.blog.md)                 | Blog                          |

package/dist/README.piano.md

@@ -0,0 +1,42 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Coding like a pianist
+
+Tricks and tips for high performance coders
+
+## Content <!-- omit in toc -->
+
+- [Vscode](#vscode)
+  - [Quick open files](#quick-open-files)
+  - [Multi cursor search and replace](#multi-cursor-search-and-replace)
+
+## Vscode
+
+### Quick open files
+
+❌ Don't open files by clicking through the folder hierarchy.
+
+✅ Quick open files by pressing `Cmd+Shift+P`, entering fragments of the
+file name and pressing `enter`.
+
+### Multi cursor search and replace
+
+❌ Don't use `Cmd+F` to search and replace files
+
+✅ Double click a word to be searched and replaced
+
+Press `Ctrl+ddd...` to create a multi cursor on all occurrences of the word
+
+Modify the word
+
+Press `ESC` to finish multi cursor edit
+
+When doing this the first time, search will not be case sensitive
+
+Press `Cmd+F`, click `Aa` to make `Ctrl+d` multi case sensitive

package/dist/README.public.md

@@ -0,0 +1,15 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# @rljson/io-sqlite
+
+Todo: Add description here
+
+## Example
+
+[src/example.ts](src/example.ts)

package/dist/README.trouble.md

@@ -0,0 +1,23 @@
+<!--
+@license
+Copyright (c) 2025 Rljson
+
+Use of this source code is governed by terms that can be
+found in the LICENSE file in the root of this package.
+-->
+
+# Trouble shooting
+
+## Table of contents <!-- omit in toc -->
+
+- [Vscode Windows: Debugging is not working](#vscode-windows-debugging-is-not-working)
+
+## Vscode Windows: Debugging is not working
+
+Date: 2025-03-08
+
+⚠️ IMPORTANT: On Windows, please check out the repo on drive C. There is a bug
+in the VS Code Vitest extension (v1.14.4), which prevents test debugging from
+working: <https://github.com/vitest-dev/vscode/issues/548> Please check from
+time to time if the issue has been fixed and remove this note once it is
+resolved.

package/dist/example.d.ts

@@ -0,0 +1 @@
+export declare const example: () => void;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './io-sqlite-node.ts';
+export * from './sql-statements.ts';

package/dist/index.js

@@ -0,0 +1,619 @@
+import { hip, hsh } from "@rljson/hash";
+import { IoDbNameMapping, IoTools } from "@rljson/io";
+import { IsReady } from "@rljson/is-ready";
+import { iterateTables } from "@rljson/rljson";
+import { mkdirSync } from "node:fs";
+import { unlink } from "node:fs/promises";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+function randomDbName() {
+  return (() => {
+    const randomCode = Math.floor(Math.random() * 1e10).toString().padStart(10, "0");
+    return `test_${randomCode}.db`;
+  })();
+}
+class SqlStatements {
+  _map = new IoDbNameMapping();
+  /**
+   * Converts a JSON value type to an SQLite data type.
+   * @param dataType - The JSON value type to convert.
+   * @returns - The corresponding SQLite data type.
+   */
+  jsonToSqlType(dataType) {
+    switch (dataType) {
+      case "string":
+        return "TEXT";
+      case "jsonArray":
+        return "TEXT";
+      case "json":
+        return "TEXT";
+      case "number":
+        return "REAL";
+      case "boolean":
+        return "INTEGER";
+      case "jsonValue":
+        return "TEXT";
+    }
+  }
+  get tableKey() {
+    return `SELECT name FROM sqlite_master WHERE type='table' AND name=?`;
+  }
+  get tableKeys() {
+    return `SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`;
+  }
+  rowCount(tableKey) {
+    return `SELECT COUNT(*) AS RECORDCOUNT FROM ${this._map.addTableSuffix(
+      tableKey
+    )}`;
+  }
+  allData(tableKey, namedColumns) {
+    if (!namedColumns) {
+      namedColumns = `*`;
+    }
+    return `SELECT ${namedColumns} FROM ${tableKey}`;
+  }
+  get tableCfg() {
+    return `SELECT * FROM ${this._map.addTableSuffix(
+      this._map.tableNames.main
+    )} WHERE ${this._map.addColumnSuffix("key")} = ?`;
+  }
+  get tableCfgs() {
+    return `SELECT * FROM ${this._map.addTableSuffix(
+      this._map.tableNames.main
+    )}`;
+  }
+  /* v8 ignore next -- @preserve */
+  get currentTableCfg() {
+    const sql = [
+      "WITH versions AS (",
+      " SELECT _hash_col, key_col, MAX(json_each.key) AS max_val",
+      " FROM tableCfgs_tbl, json_each(columns_col)",
+      " WHERE json_each.value IS NOT NULL",
+      " AND key_col = ? GROUP BY _hash_col, key_col)",
+      "SELECT * FROM tableCfgs_tbl tt",
+      " LEFT JOIN versions ON tt._hash_col = versions._hash_col",
+      " WHERE versions.max_val = (SELECT MAX(max_val) FROM versions);"
+    ];
+    return sql.join("\n");
+  }
+  get currentTableCfgs() {
+    const sql = [
+      "SELECT",
+      "  *",
+      "FROM",
+      "  tableCfgs_tbl",
+      "WHERE",
+      "  _hash_col IN (",
+      "    WITH",
+      "      column_count AS (",
+      "        SELECT",
+      "          _hash_col,",
+      "          key_col,",
+      "          MAX(json_each.key) AS max_val",
+      "        FROM",
+      "          tableCfgs_tbl,",
+      "          json_each (columns_col)",
+      "        WHERE",
+      "          json_each.value IS NOT NULL",
+      "        GROUP BY",
+      "          _hash_col,",
+      "          key_col",
+      "      ),",
+      "      max_tables AS (",
+      "        SELECT",
+      "          key_col,",
+      "          MAX(max_val) AS newest",
+      "        FROM",
+      "          column_count",
+      "        GROUP BY",
+      "          key_col",
+      "      )",
+      "    SELECT",
+      "      cc._hash_col",
+      "    FROM",
+      "      column_count cc",
+      "      LEFT JOIN max_tables mt ON cc.key_col = mt.key_col",
+      "      AND cc.max_val = mt.newest",
+      "    WHERE",
+      "      mt.newest IS NOT NULL",
+      "  );"
+    ];
+    return sql.join("\n");
+  }
+  get articleExists() {
+    return "SELECT cl.layer, ar.assign FROM catalogLayers cl\nLEFT JOIN articleSets ar\nON cl.articleSetsRef = ar._hash\nWHERE cl.winNumber = ? ";
+  }
+  get catalogExists() {
+    return "SELECT 1 FROM catalogLayers WHERE winNumber = ?";
+  }
+  contentType() {
+    const sourceTable = this._map.addTableSuffix(this._map.tableNames.main);
+    const resultCol = this._map.addColumnSuffix("type");
+    const sql = `SELECT ${resultCol} as contentType FROM [${sourceTable}] WHERE key_col =?`;
+    return sql;
+  }
+  insertTableCfg() {
+    const columnKeys = IoTools.tableCfgsTableCfg.columns.map((col) => col.key);
+    const columnKeysWithPostfix = columnKeys.map(
+      (col) => this._map.addColumnSuffix(col)
+    );
+    const columnsSql = columnKeysWithPostfix.join(", ");
+    const valuesSql = "?, ".repeat(columnKeys.length - 1) + "?";
+    return `INSERT OR IGNORE INTO ${this._map.addTableSuffix(
+      this._map.tableNames.main
+    )} ( ${columnsSql} ) VALUES (${valuesSql})`;
+  }
+  tableExists() {
+    return `SELECT name FROM sqlite_master WHERE type='table' AND name=?;`;
+  }
+  get tableType() {
+    return `SELECT ${this._map.addColumnSuffix(
+      "type"
+    )} AS type FROM ${this._map.addTableSuffix(this._map.tableNames.main)}
+      WHERE ${this._map.addColumnSuffix("key")} = ?
+      AND ${this._map.addColumnSuffix("version")}
+      = (SELECT MAX(${this._map.addColumnSuffix("version")})
+        FROM ${this._map.addTableSuffix(this._map.tableNames.main)}
+        WHERE ${this._map.addColumnSuffix("key")} = ?)`;
+  }
+  columnKeys(tableKey) {
+    return `PRAGMA table_info(${tableKey})`;
+  }
+  createFullTable(tableKey, columnsDefinition, foreignKeys) {
+    return `CREATE TABLE ${tableKey} (${columnsDefinition}, ${foreignKeys})`;
+  }
+  dropTable(tableKey) {
+    return `DROP TABLE IF EXISTS ${this._map.addTableSuffix(tableKey)}`;
+  }
+  createTempTable(tableKey) {
+    return `CREATE TABLE ${this._map.addTmpSuffix(
+      tableKey
+    )} AS SELECT * FROM ${this._map.addTableSuffix(tableKey)}`;
+  }
+  dropTempTable(tableKey) {
+    return `DROP TABLE IF EXISTS ${this._map.addTmpSuffix(tableKey)}`;
+  }
+  fillTable(tableKey, commonColumns) {
+    return `INSERT OR IGNORE INTO ${this._map.addTableSuffix(
+      tableKey
+    )} (${commonColumns}) SELECT ${commonColumns} FROM ${this._map.addTmpSuffix(
+      tableKey
+    )}`;
+  }
+  deleteFromTable(tableKey, winNumber) {
+    return `DELETE FROM ${tableKey} WHERE winNumber = '${winNumber}'`;
+  }
+  addColumn(tableKey, columnName, columnType) {
+    return `ALTER TABLE ${tableKey} ADD COLUMN ${columnName} ${columnType}`;
+  }
+  selection(tableKey, columns, whereClause) {
+    return `SELECT ${columns} FROM ${tableKey} WHERE ${whereClause}`;
+  }
+  articleSetsRefs(winNumber) {
+    return `SELECT layer, articleSetsRef FROM catalogLayers WHERE winNumber = '${winNumber}'`;
+  }
+  currentCount(tableKey) {
+    return `SELECT COUNT(*) FROM ${this._map.addTableSuffix(tableKey)}`;
+  }
+  createTable(tableCfg) {
+    const sqltableKey = this._map.addTableSuffix(tableCfg.key);
+    const columnsCfg = tableCfg.columns;
+    const sqlCreateColumns = columnsCfg.map((col) => {
+      const sqliteType = this.jsonToSqlType(col.type);
+      return `${this._map.addColumnSuffix(col.key)} ${sqliteType}`;
+    }).join(", ");
+    const conKey = `${this._map.addColumnSuffix(
+      this._map.primaryKeyColumn
+    )} TEXT`;
+    const primaryKey = `${conKey} PRIMARY KEY NOT NULL`;
+    const colsWithPrimaryKey = sqlCreateColumns.replace(conKey, primaryKey);
+    return `CREATE TABLE IF NOT EXISTS ${sqltableKey} (${colsWithPrimaryKey})`;
+  }
+  alterTable(tableKey, addedColumns) {
+    const tableKeyWithSuffix = this._map.addTableSuffix(tableKey);
+    const statements = [];
+    for (const col of addedColumns) {
+      const columnKey = this._map.addColumnSuffix(col.key);
+      const columnType = this.jsonToSqlType(col.type);
+      statements.push(
+        `ALTER TABLE ${tableKeyWithSuffix} ADD COLUMN ${columnKey} ${columnType};`
+      );
+    }
+    return statements;
+  }
+  get createTableCfgsTable() {
+    return this.createTable(IoTools.tableCfgsTableCfg);
+  }
+  get tableTypeCheck() {
+    return `SELECT ${this._map.addColumnSuffix(
+      "type"
+    )} FROM ${this._map.addTableSuffix(
+      this._map.tableNames.main
+    )} WHERE ${this._map.addColumnSuffix("key")} = ?`;
+  }
+}
+class IoSqliteNode {
+  _ioTools;
+  _isReady = new IsReady();
+  _sql;
+  _map = new IoDbNameMapping();
+  _persistence = true;
+  _dbFileName;
+  _undeletedFile;
+  constructor() {
+    this._sql = new SqlStatements();
+  }
+  get isOpen() {
+    return this._isOpen;
+  }
+  async init() {
+    this._openOrCreateDatabase();
+    this._ioTools = new IoTools(this);
+    this._initTableCfgs();
+    await this._ioTools.initRevisionsTable();
+    this._isReady.resolve();
+  }
+  db;
+  static example = async () => {
+    const ioSqliteServer = new IoSqliteNode();
+    ioSqliteServer.dbFileName = randomDbName();
+    return ioSqliteServer;
+  };
+  async close() {
+    this._isOpen = false;
+    try {
+      this.db.close();
+    } catch (err) {
+      if (err.code === "ERR_INVALID_STATE") {
+        return;
+      } else {
+        throw err;
+      }
+    }
+  }
+  isReady() {
+    return this._isReady.promise;
+  }
+  dump() {
+    return this._dump();
+  }
+  dumpTable(request) {
+    return this._dumpTable(request);
+  }
+  async contentType(request) {
+    const result = this.db.prepare(this._sql.contentType()).get(request.table);
+    return result?.contentType;
+  }
+  async tableExists(tableKey) {
+    return this._tableExists(tableKey);
+  }
+  async createOrExtendTable(request) {
+    return this._createOrExtendTable(request);
+  }
+  async rawTableCfgs() {
+    const tableCfg = IoTools.tableCfgsTableCfg;
+    const resultSet = this.db.prepare(this._sql.tableCfgs).all();
+    const rowArray = [];
+    for (const row of resultSet) {
+      rowArray.push(row);
+    }
+    const parsedReturnValue = this._parseData(rowArray, tableCfg);
+    return parsedReturnValue;
+  }
+  async write(request) {
+    await this._write(request);
+  }
+  readRows(request) {
+    return this._readRows(request);
+  }
+  async rowCount(table) {
+    await this._ioTools.throwWhenTableDoesNotExist(table);
+    const resultSet = this.db.prepare(this._sql.rowCount(table)).all();
+    const countRaw = resultSet[0]["RECORDCOUNT"];
+    const count = Number(countRaw);
+    return count;
+  }
+  // Sqlite-specific functions************************************************
+  async execute(sql) {
+    try {
+      const stmt = this.db.prepare(sql);
+      if (sql.trim().toUpperCase().startsWith("SELECT")) {
+        return stmt.all();
+      } else {
+        return stmt.run();
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Malformed SQL statement: ${errorMessage}`);
+    }
+  }
+  get undeletedFile() {
+    return this._undeletedFile;
+  }
+  set dbFileName(fileName) {
+    if (!fileName) {
+      this._persistence = false;
+      this._dbFileName = void 0;
+      return;
+    }
+    this._persistence = true;
+    this._dbFileName = `./data/${fileName}`;
+  }
+  get dbFileName() {
+    return this._dbFileName;
+  }
+  async openOrCreateDatabase() {
+    this._openOrCreateDatabase();
+  }
+  _openOrCreateDatabase() {
+    if (!this._dbFileName) {
+      this._persistence = false;
+      this.db = new DatabaseSync(":memory:");
+    } else {
+      mkdirSync(dirname(`${this._dbFileName}`), { recursive: true });
+      this.db = new DatabaseSync(`${this._dbFileName}`);
+      this._persistence = true;
+    }
+    this._isOpen = true;
+    return this._persistence ? this._dbFileName : "in-memory";
+  }
+  async deleteDatabase() {
+    if (this._isOpen) {
+      this.db.close();
+      this._isOpen = false;
+    }
+    if (this._persistence) {
+      await new Promise((resolve) => setTimeout(resolve, 800));
+      let deleted = false;
+      for (let attempt = 1; attempt <= 5; attempt++) {
+        try {
+          await unlink(this._dbFileName);
+          deleted = true;
+          break;
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            deleted = true;
+            break;
+          }
+          if (attempt < 5) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+          }
+        }
+      }
+      if (!deleted) {
+        this._undeletedFile = this._dbFileName;
+      }
+    }
+  }
+  //********Private section */
+  _isOpen = false;
+  async _dump() {
+    const returnFile = {};
+    const resultSet = this.db.prepare(this._sql.tableKeys).all();
+    const tableNames = resultSet.map((row) => row.name).filter((name) => name != null);
+    for (const table of tableNames) {
+      const tableDump = await this._dumpTable({
+        table: this._map.removeTableSuffix(table)
+      });
+      returnFile[this._map.removeTableSuffix(table)] = tableDump[this._map.removeTableSuffix(table)];
+    }
+    this._addMissingHashes(returnFile);
+    return returnFile;
+  }
+  _addMissingHashes(rljson) {
+    hip(rljson, { updateExistingHashes: false, throwOnWrongHashes: false });
+  }
+  _parseData(data, tableCfg) {
+    const columnTypes = tableCfg.columns.map((col) => col.type);
+    const columnKeys = tableCfg.columns.map((col) => col.key);
+    const convertedResult = [];
+    for (const row of data) {
+      const convertedRow = {};
+      for (let colNum = 0; colNum < columnKeys.length; colNum++) {
+        const key = columnKeys[colNum];
+        const keyWithSuffix = this._map.addColumnSuffix(key);
+        const type = columnTypes[colNum];
+        const val = row[keyWithSuffix];
+        if (val === void 0) {
+          continue;
+        }
+        if (val === null) {
+          continue;
+        }
+        switch (type) {
+          case "boolean":
+            convertedRow[key] = val !== 0;
+            break;
+          case "jsonArray":
+          case "json":
+            convertedRow[key] = JSON.parse(val);
+            break;
+          case "string":
+          case "number":
+            convertedRow[key] = val;
+            break;
+          /* v8 ignore next -- @preserve */
+          default:
+            throw new Error("Unsupported column type " + type);
+        }
+      }
+      convertedResult.push(convertedRow);
+    }
+    return convertedResult;
+  }
+  _initTableCfgs = () => {
+    const tableCfg = IoTools.tableCfgsTableCfg;
+    this.db.prepare(this._sql.createTable(tableCfg)).run();
+    const valuesFromTableCfg = this._serializeRow(tableCfg, tableCfg);
+    this.db.prepare(this._sql.insertTableCfg()).run(...valuesFromTableCfg);
+  };
+  _serializeRow(rowAsJson, tableCfg) {
+    const result = [];
+    for (const col of tableCfg.columns) {
+      const key = col.key;
+      let value = rowAsJson[key] ?? null;
+      const valueType = typeof value;
+      if (value !== null && valueType === "object") {
+        value = JSON.stringify(value);
+      } else if (valueType === "boolean") {
+        value = value ? 1 : 0;
+      }
+      result.push(value);
+    }
+    return result;
+  }
+  async _dumpTable(request) {
+    await this._ioTools.throwWhenTableDoesNotExist(request.table);
+    const tableKey = this._map.addTableSuffix(request.table);
+    const tableCfg = await this._ioTools.tableCfg(request.table);
+    const columnKeys = tableCfg.columns.map((col) => col.key);
+    const columnKeysWithSuffix = columnKeys.map(
+      (col) => this._map.addColumnSuffix(col)
+    );
+    const resultSet = this.db.prepare(this._sql.allData(tableKey, columnKeysWithSuffix.join(", "))).all();
+    const parsedReturnData = this._parseData(resultSet, tableCfg);
+    const tableCfgHash = tableCfg._hash;
+    const table = {
+      _type: tableCfg.type,
+      _data: parsedReturnData,
+      _tableCfg: tableCfgHash,
+      _hash: ""
+    };
+    this._ioTools.sortTableDataAndUpdateHash(table);
+    const returnFile = {};
+    returnFile[request.table] = table;
+    return returnFile;
+  }
+  // ...........................................................................
+  async _write(request) {
+    const hashedData = hsh(request.data);
+    const errorStore = /* @__PURE__ */ new Map();
+    let errorCount = 0;
+    await this._ioTools.throwWhenTablesDoNotExist(request.data);
+    await this._ioTools.throwWhenTableDataDoesNotMatchCfg(request.data);
+    await iterateTables(hashedData, async (tableName, tableData) => {
+      const tableCfg = await this._ioTools.tableCfg(tableName);
+      const tableKeyWithSuffix = this._map.addTableSuffix(tableName);
+      for (const row of tableData._data) {
+        const columnKeys = tableCfg.columns.map((col) => col.key);
+        const columnKeysWithPostfix = columnKeys.map(
+          (column) => this._map.addColumnSuffix(column)
+        );
+        const placeholders = columnKeys.map(() => "?").join(", ");
+        const query = `INSERT OR IGNORE INTO ${tableKeyWithSuffix} (${columnKeysWithPostfix.join(
+          ", "
+        )}) VALUES (${placeholders})`;
+        const serializedRow = this._serializeRow(row, tableCfg);
+        try {
+          this.db.prepare(query).run(...serializedRow);
+        } catch (error) {
+          if (error.code === "SQLITE_CONSTRAINT_PRIMARYKEY") {
+            return;
+          }
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          errorCount++;
+          errorStore.set(
+            errorCount,
+            `Error inserting into table ${tableName}: ${errorMessage}`
+          );
+        }
+      }
+    });
+    if (errorCount > 0) {
+      const errorMessages = Array.from(errorStore.values()).join(", ");
+      throw new Error(`Errors occurred: ${errorMessages}`);
+    }
+  }
+  async _tableExists(tableKey) {
+    const tableKeyWithSuffix = this._map.addTableSuffix(tableKey);
+    const result = this.db.prepare(this._sql.tableExists()).get(tableKeyWithSuffix);
+    return result?.name === tableKeyWithSuffix ? true : false;
+  }
+  _whereString(whereClause) {
+    let whereString = " ";
+    for (const [column, value] of whereClause) {
+      const columnWithFix = this._map.addColumnSuffix(column);
+      if (typeof value === "string") {
+        whereString += `${columnWithFix} = '${value}' AND `;
+      } else if (typeof value === "number") {
+        whereString += `${columnWithFix} = ${value} AND `;
+      } else if (typeof value === "boolean") {
+        whereString += `${columnWithFix} = ${value ? 1 : 0} AND `;
+      } else if (value === null) {
+        whereString += `${columnWithFix} IS NULL AND `;
+      } else if (typeof value === "object") {
+        whereString += `${columnWithFix} = '${JSON.stringify(value)}' AND `;
+      } else {
+        throw new Error(`Unsupported value type for column ${column}`);
+      }
+    }
+    whereString = whereString.endsWith("AND ") ? whereString.slice(0, -5) : whereString;
+    return whereString;
+  }
+  async _createOrExtendTable(request) {
+    await this._ioTools.throwWhenTableIsNotCompatible(request.tableCfg);
+    const tableKey = request.tableCfg.key;
+    const tableCfgHashed = hsh(request.tableCfg);
+    const stmt = this.db.prepare(this._sql.tableCfg);
+    const exists = stmt.get(tableKey);
+    if (!exists) {
+      this._createTable(tableCfgHashed, request);
+    } else {
+      await this._extendTable(tableCfgHashed);
+    }
+  }
+  async _readRows(request) {
+    await this._ioTools.throwWhenTableDoesNotExist(request.table);
+    await this._ioTools.throwWhenColumnDoesNotExist(request.table, [
+      ...Object.keys(request.where)
+    ]);
+    const tableKeyWithSuffix = this._map.addTableSuffix(request.table);
+    const tableCfg = await this._ioTools.tableCfg(request.table);
+    const whereString = this._whereString(Object.entries(request.where));
+    const query = `SELECT * FROM ${tableKeyWithSuffix} WHERE${whereString}`;
+    const resultSet = this.db.prepare(query).all();
+    const convertedResult = this._parseData(resultSet, tableCfg);
+    const table = {
+      _data: convertedResult,
+      _type: tableCfg.type
+    };
+    this._ioTools.sortTableDataAndUpdateHash(table);
+    const result = {
+      [request.table]: table
+    };
+    return result;
+  }
+  _createTable(tableCfgHashed, request) {
+    this._insertTableCfg(tableCfgHashed);
+    this.db.exec(this._sql.createTable(request.tableCfg));
+  }
+  _insertTableCfg(tableCfgHashed) {
+    hip(tableCfgHashed);
+    const values = this._serializeRow(
+      tableCfgHashed,
+      IoTools.tableCfgsTableCfg
+    );
+    this.db.prepare(this._sql.insertTableCfg()).run(...values);
+  }
+  async _extendTable(newTableCfg) {
+    const tableKey = newTableCfg.key;
+    const oldTableCfg = await this._ioTools.tableCfg(tableKey);
+    const addedColumns = [];
+    for (let i = oldTableCfg.columns.length; i < newTableCfg.columns.length; i++) {
+      const newColumn = newTableCfg.columns[i];
+      addedColumns.push(newColumn);
+    }
+    if (addedColumns.length === 0) {
+      return;
+    }
+    this._insertTableCfg(newTableCfg);
+    const alter = this._sql.alterTable(tableKey, addedColumns);
+    for (const statement of alter) {
+      this.db.prepare(statement).run();
+    }
+  }
+}
+export {
+  IoSqliteNode,
+  SqlStatements
+};

package/dist/io-sqlite-node.d.ts

@@ -0,0 +1,64 @@
+import { Io } from '@rljson/io';
+import { Json, JsonValue } from '@rljson/json';
+import { ContentType, Rljson, TableCfg, TableKey } from '@rljson/rljson';
+import { DatabaseSync } from 'node:sqlite';
+export declare class IoSqliteNode implements Io {
+    private _ioTools;
+    private _isReady;
+    private _sql;
+    private _map;
+    private _persistence;
+    private _dbFileName;
+    private _undeletedFile;
+    constructor();
+    get isOpen(): boolean;
+    init(): Promise<void>;
+    db: DatabaseSync;
+    static example: () => Promise<IoSqliteNode>;
+    close(): Promise<void>;
+    isReady(): Promise<void>;
+    dump(): Promise<Rljson>;
+    dumpTable(request: {
+        table: string;
+    }): Promise<Rljson>;
+    contentType(request: {
+        table: string;
+    }): Promise<ContentType>;
+    tableExists(tableKey: TableKey): Promise<boolean>;
+    createOrExtendTable(request: {
+        tableCfg: TableCfg;
+    }): Promise<void>;
+    rawTableCfgs(): Promise<TableCfg[]>;
+    write(request: {
+        data: Rljson;
+    }): Promise<void>;
+    readRows(request: {
+        table: string;
+        where: {
+            [column: string]: JsonValue;
+        };
+    }): Promise<Rljson>;
+    rowCount(table: string): Promise<number>;
+    execute(sql: string): Promise<any>;
+    get undeletedFile(): string | undefined;
+    set dbFileName(fileName: string | undefined);
+    get dbFileName(): string | undefined;
+    openOrCreateDatabase(): Promise<void>;
+    private _openOrCreateDatabase;
+    deleteDatabase(): Promise<void>;
+    private _isOpen;
+    private _dump;
+    _addMissingHashes(rljson: Json): void;
+    private _parseData;
+    private _initTableCfgs;
+    private _serializeRow;
+    private _dumpTable;
+    private _write;
+    _tableExists(tableKey: string): Promise<boolean>;
+    _whereString(whereClause: [string, JsonValue][]): string;
+    private _createOrExtendTable;
+    private _readRows;
+    private _createTable;
+    private _insertTableCfg;
+    private _extendTable;
+}

package/dist/random-db-name.d.ts

@@ -0,0 +1 @@
+export declare function randomDbName(): string;

package/dist/sql-statements.d.ts

@@ -0,0 +1,40 @@
+import { JsonValueType } from '@rljson/json';
+import { ColumnCfg, TableCfg, TableKey } from '@rljson/rljson';
+export declare class SqlStatements {
+    private _map;
+    /**
+     * Converts a JSON value type to an SQLite data type.
+     * @param dataType - The JSON value type to convert.
+     * @returns - The corresponding SQLite data type.
+     */
+    jsonToSqlType(dataType: JsonValueType): string;
+    get tableKey(): string;
+    get tableKeys(): string;
+    rowCount(tableKey: string): string;
+    allData(tableKey: string, namedColumns?: string): string;
+    get tableCfg(): string;
+    get tableCfgs(): string;
+    get currentTableCfg(): string;
+    get currentTableCfgs(): string;
+    get articleExists(): string;
+    get catalogExists(): string;
+    contentType(): string;
+    insertTableCfg(): string;
+    tableExists(): string;
+    get tableType(): string;
+    columnKeys(tableKey: string): string;
+    createFullTable(tableKey: string, columnsDefinition: string, foreignKeys: string): string;
+    dropTable(tableKey: string): string;
+    createTempTable(tableKey: string): string;
+    dropTempTable(tableKey: string): string;
+    fillTable(tableKey: string, commonColumns: string): string;
+    deleteFromTable(tableKey: string, winNumber: string): string;
+    addColumn(tableKey: string, columnName: string, columnType: string): string;
+    selection(tableKey: string, columns: string, whereClause: string): string;
+    articleSetsRefs(winNumber: string): string;
+    currentCount(tableKey: string): string;
+    createTable(tableCfg: TableCfg): string;
+    alterTable(tableKey: TableKey, addedColumns: ColumnCfg[]): string[];
+    get createTableCfgsTable(): string;
+    get tableTypeCheck(): string;
+}

package/dist/src/example.ts

@@ -0,0 +1,26 @@
+// @license
+// Copyright (c) 2025 Rljson
+//
+// Use of this source code is governed by terms that can be
+// found in the LICENSE file in the root of this package.
+
+import { IoSqliteNode } from './io-sqlite-node.ts';
+
+export const example = () => {
+  // Print methods
+  const l = console.log;
+  const h1 = (text: string) => l(`${text}`);
+  const h2 = (text: string) => l(`  ${text.split('\n')}`);
+  const p = (text: string) => l(`    ${text}`);
+
+  // Example
+  h1('IoSqliteNode.example');
+  h2('Returns an instance of the io-sqlite-node.');
+  const example = IoSqliteNode.example();
+  p(JSON.stringify(example, null, 2));
+};
+
+/*
+// Run via "npx vite-node src/example.ts"
+example();
+*/

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@rljson/io-sqlite-node",
+  "version": "1.0.3",
+  "description": "IoSql rljson files",
+  "homepage": "https://github.com/rljson/io-sqlite_node",
+  "bugs": "https://github.com/rljson/io-sqlite-node/issues",
+  "private": false,
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rljson/io-sqlite-node.git"
+  },
+  "main": "dist/io-sqlite-node.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "scripts": {
+    "build": "pnpm vite build && tsc && node scripts/copy-readme-to-dist.js && node scripts/copy-file.js src/example.ts dist/src",
+    "test": "pnpm installConformanceTests && pnpm vitest --coverage --no-file-parallelism --run  && pnpm run lint",
+    "prebuild": "pnpm run test",
+    "prepublishOnly": "pnpm run build",
+    "lint": "pnpm eslint",
+    "updateGoldens": "cross-env UPDATE_GOLDENS=true pnpm test",
+    "installConformanceTests": "node scripts/install-conformance-tests.js"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.0.8",
+    "@types/sql.js": "^1.4.9",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    "@vitest/coverage-v8": "^4.0.17",
+    "cross-env": "^10.1.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-jsdoc": "^62.0.0",
+    "eslint-plugin-tsdoc": "^0.5.0",
+    "globals": "^17.0.0",
+    "jsdoc": "^4.0.5",
+    "read-pkg": "^10.0.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.53.0",
+    "vite": "^7.3.1",
+    "vite-node": "^5.2.0",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-node-polyfills": "^0.25.0",
+    "vite-tsconfig-paths": "^6.0.4",
+    "vitest": "^4.0.17",
+    "vitest-dom": "^0.1.1"
+  },
+  "dependencies": {
+    "@rljson/hash": "^0.0.17",
+    "@rljson/io": "^0.0.63",
+    "@rljson/is-ready": "^0.0.17",
+    "@rljson/json": "^0.0.23",
+    "@rljson/rljson": "^0.0.73",
+    "path-browserify": "^1.0.1",
+    "shx": "^0.4.0",
+    "sql.js": "^1.13.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  },
+  "packageManager": "pnpm@10.21.0"
+}