jsql-neo 5.3.1 → 5.4.0

package/lib/sqlite_worker.js

@@ -20,7 +20,7 @@ function startEngine(filename, options) {
   const opts = options || {};
   const isMemory = filename === ':memory:' || !filename;
   if (opts.engine === 'native') {
-    const { NativeJSQL } = require('./native_client');
+    const { JSQL: NativeJSQL } = require('./native_client');
     const engine = new NativeJSQL({ mode: 'memory' });
     db = {
       start: async () => { await engine.start(); },
@@ -30,10 +30,14 @@ function startEngine(filename, options) {
       dropTable: n => engine.dropTable(n),
       insert: (n, rows) => engine.insert(n, rows),
       find: (n, f, o) => engine.find(n, f, o),
+      updateById: (n, id, data) => engine.updateById(n, id, data),
       updateByIds: (n, e) => engine.updateByIds(n, e),
       removeByIds: (n, ids) => engine.removeByIds(n, ids),
       count: (n, f) => engine.count ? engine.count(n, f) : engine.find(n, f || {}, {}).then(rs => rs.length),
       getTableSchema: n => engine._schemas[n] || null,
+      beginTx: () => engine.beginTx(),
+      commitTx: id => engine.commitTx(id),
+      rollbackTx: id => engine.rollbackTx(id),
       truncate: async () => { throw new Error('truncate not supported on native engine'); },
       flush: async () => { if (engine.flush) await engine.flush(); },
       listTables: () => Array.from(engine._tableNames || []),

package/lib/wasm_client.js

@@ -23,14 +23,52 @@ const NATIVE_TYPE_MAP = {
   int: 'integer',
 };
 
+function parseShorthandSchema(str) {
+  const def = { type: str };
+  const strip = (re) => {
+    const next = def.type.replace(re, '').trim();
+    def.type = next || def.type;
+  };
+  if (/\bprimary\s+key\b/i.test(def.type)) { def.primaryKey = true; strip(/\bprimary\s+key\b/gi); }
+  if (/\bauto_?increment\b/i.test(def.type)) { def.autoIncrement = true; strip(/\bauto_?increment\b/gi); }
+  if (/\bnot\s+null\b/i.test(def.type)) { def.required = true; strip(/\bnot\s+null\b/gi); }
+  if (/\bunique\b/i.test(def.type)) { def.unique = true; strip(/\bunique\b/gi); }
+  if (/\bdefault\s+(\S+)/i.test(def.type)) {
+    const m = def.type.match(/\bdefault\s+(\S+)/i);
+    def.default = m[1].replace(/^['"]|['"]$/g, '');
+    strip(/\bdefault\s+\S+/gi);
+  }
+  return def;
+}
+
+function parseSchemaString(str) {
+  const out = {};
+  for (const seg of str.split(',')) {
+    const trimmed = seg.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split(/\s+/);
+    const name = parts.shift();
+    const def = parseShorthandSchema(parts.join(' ').toLowerCase().trim());
+    if (def.type.length === 0) def.type = 'string';
+    out[name] = def;
+  }
+  return out;
+}
+
 function mapNativeSchema(schema) {
+  if (typeof schema === 'string') schema = parseSchemaString(schema);
   const mapped = {};
   for (const [field, def] of Object.entries(schema || {})) {
     if (typeof def === 'string') {
-      mapped[field] = { type: NATIVE_TYPE_MAP[def.toLowerCase()] || def.toLowerCase() };
+      const parsed = parseShorthandSchema(def.toLowerCase().trim());
+      if (parsed.type.length === 0) parsed.type = 'string';
+      mapped[field] = { ...parsed, type: NATIVE_TYPE_MAP[parsed.type] || parsed.type };
     } else if (def && typeof def === 'object') {
       const t = (def.type || 'string').toLowerCase();
-      mapped[field] = { ...def, type: NATIVE_TYPE_MAP[t] || t };
+      const out = { ...def, type: NATIVE_TYPE_MAP[t] || t };
+      if (out.primary_key !== undefined && out.primaryKey === undefined) { out.primaryKey = out.primary_key; delete out.primary_key; }
+      if (out.auto_increment !== undefined && out.autoIncrement === undefined) { out.autoIncrement = out.auto_increment; delete out.auto_increment; }
+      mapped[field] = out;
     } else {
       mapped[field] = { type: 'string' };
     }
@@ -39,25 +77,46 @@ function mapNativeSchema(schema) {
 }
 
 function restoreRow(row, schema) {
-  if (!schema || typeof row !== 'object' || row === null) return row;
-  const out = {};
-  for (const [field, def] of Object.entries(row)) {
-    if (field === 'fields' && typeof row[field] === 'object' && row[field] !== null) {
-      out[field] = restoreRow(row[field], schema);
-      continue;
+  if (typeof row !== 'object' || row === null) return row;
+  let src = row;
+  if (row.fields && typeof row.fields === 'object' && row.fields !== null) {
+    src = { ...row.fields };
+    if (row.id !== undefined) {
+      const pkCols = [];
+      if (schema) {
+        for (const [k, def] of Object.entries(schema)) {
+          if (def && typeof def === 'object' && def.autoIncrement) continue;
+          const isPk = typeof def === 'string'
+            ? /\bprimary\s+key\b/i.test(def)
+            : !!(def && (def.primaryKey || def.primary_key));
+          if (isPk) pkCols.push(k);
+        }
+      } else if (src.id === undefined) {
+        pkCols.push('id');
+      }
+      for (const c of pkCols) {
+        const v = src[c];
+        if (v === undefined || v === null || v === 0 || v === '' || v === false) src[c] = row.id;
+      }
     }
+    if (row.created_at !== undefined) src.created_at = row.created_at;
+    if (row.updated_at !== undefined) src.updated_at = row.updated_at;
+  }
+  if (!schema) return src;
+  const out = {};
+  for (const [field, value] of Object.entries(src)) {
     const colDef = schema[field];
     let t = null;
     if (typeof colDef === 'string') t = colDef.toLowerCase();
     else if (colDef && typeof colDef === 'object' && colDef.type) t = String(colDef.type).toLowerCase();
-    if (['json', 'array', 'object'].includes(t) && typeof row[field] === 'string') {
-      try { out[field] = JSON.parse(row[field]); } catch (e) { out[field] = row[field]; }
-    } else if ((t === 'integer' || t === 'int' || t === 'bigint') && typeof row[field] === 'string' && /^-?\d+$/.test(row[field])) {
-      out[field] = Number(row[field]);
-    } else if ((t === 'float' || t === 'double' || t === 'number') && typeof row[field] === 'string' && !Number.isNaN(Number(row[field]))) {
-      out[field] = Number(row[field]);
+    if (['json', 'array', 'object'].includes(t) && typeof value === 'string') {
+      try { out[field] = JSON.parse(value); } catch (e) { out[field] = value; }
+    } else if ((t === 'integer' || t === 'int' || t === 'bigint') && typeof value === 'string' && /^-?\d+$/.test(value)) {
+      out[field] = Number(value);
+    } else if ((t === 'float' || t === 'double' || t === 'number') && typeof value === 'string' && !Number.isNaN(Number(value))) {
+      out[field] = Number(value);
     } else {
-      out[field] = row[field];
+      out[field] = value;
     }
   }
   return out;
@@ -230,6 +289,7 @@ class JSQL {
     this._bufferSize = 0;
     this._tableNames = new Set();
     this._schemas = {};
+    this._txId = undefined;
     this._autoPlugins = opts.modules !== false;
 
     this._plugins = [];
@@ -324,6 +384,62 @@ class JSQL {
     this._emit('start', {});
   }
 
+  _pkOf(table) {
+    const schema = this._schemas[table];
+    if (!schema) return null;
+    for (const [k, def] of Object.entries(schema)) {
+      const isPk = (typeof def === 'string' && /\bprimary\s+key\b/i.test(def))
+        || !!(def && typeof def === 'object' && (def.primaryKey || def.primary_key));
+      if (isPk) return k;
+    }
+    return null;
+  }
+
+  _pkAutoIncrement(table) {
+    const schema = this._schemas[table];
+    const pk = this._pkOf(table);
+    if (!pk || !schema) return false;
+    const def = schema[pk];
+    if (typeof def === 'string') return /\bauto_?increment\b/i.test(def);
+    return !!(def && def.autoIncrement);
+  }
+
+  _coercePkId(table, id) {
+    const schema = this._schemas[table];
+    const pk = this._pkOf(table);
+    if (!schema || !pk) return id;
+    const def = schema[pk];
+    let t = null;
+    if (typeof def === 'string') t = def.toLowerCase();
+    else if (def && typeof def === 'object' && def.type) t = String(def.type).toLowerCase();
+    if (['integer', 'int', 'bigint'].includes(t)) return Number(id);
+    return id;
+  }
+
+  _findRawById(table, id) {
+    const pk = this._pkOf(table);
+    if (pk) {
+      const filter = {};
+      filter[pk] = this._coercePkId(table, id);
+      const r = safeJsonParse(wasmBindings.jsql_find(table, JSON.stringify(filter), 1, 0));
+      if (r && r.error) return r;
+      return Array.isArray(r) && r.length > 0 ? r[0] : null;
+    }
+    return safeJsonParse(wasmBindings.jsql_find_by_id(table, BigInt(id)));
+  }
+
+  _seqIdByPk(table, id) {
+    const pk = this._pkOf(table);
+    if (pk) {
+      const filter = {};
+      filter[pk] = this._coercePkId(table, id);
+      const r = safeJsonParse(wasmBindings.jsql_find(table, JSON.stringify(filter), 1, 0));
+      if (Array.isArray(r) && r.length > 0) return r[0].id;
+      return null;
+    }
+    return Number(id);
+  }
+
   async _insertBatch(table, rows) {
     const schema = this._schemas[table];
     if (schema) {
@@ -347,6 +463,15 @@ class JSQL {
     }
     const r = safeJsonParse(wasmBindings.jsql_insert_json(table, JSON.stringify(rows)));
     if (r && r.error) throw new Error(r.error);
+    if (r && Array.isArray(r) && !this._pkAutoIncrement(table)) {
+      const pk = this._pkOf(table);
+      if (pk) {
+        return r.map((seq, i) => {
+          const row = rows[i];
+          return (row && row[pk] !== undefined && row[pk] !== null) ? row[pk] : seq;
+        });
+      }
+    }
     return r;
   }
 
@@ -401,7 +526,7 @@ class JSQL {
     const r = safeJsonParse(wasmBindings.jsql_create_table(name, JSON.stringify(mapNativeSchema(schema))));
     if (r && r.ok === false) throw new Error(r.error || 'create table failed');
     this._tableNames.add(name);
-    this._schemas[name] = schema;
+    this._schemas[name] = typeof schema === 'string' ? mapNativeSchema(schema) : schema;
     this._emit('createTable', { name, schema });
     this._runHooks('afterCreateTable', [name, schema]);
     return r;
@@ -422,7 +547,7 @@ class JSQL {
   async findById(table, id) {
     await this._flush();
     if (!this._runHooks('beforeFind', [table, { id }])) return null;
-    const r = safeJsonParse(wasmBindings.jsql_find_by_id(table, BigInt(id)));
+    const r = this._findRawById(table, id);
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { id }, r]);
     const schema = this._schemas[table];
@@ -453,7 +578,11 @@ class JSQL {
   }
 
   async updateByIds(table, entries) {
-    const pairs = entries.map(([id, data]) => [Number(id), data]);
+    const pairs = [];
+    for (const [id, data] of entries) {
+      const seq = this._seqIdByPk(table, id);
+      if (seq !== null) pairs.push([seq, data]);
+    }
     if (!this._runHooks('beforeUpdate', [table, pairs])) return;
     await this._flush();
     const r = safeJsonParse(wasmBindings.jsql_update_by_ids(table, JSON.stringify(pairs)));
@@ -466,9 +595,10 @@ class JSQL {
   async removeByIds(table, ids) {
     if (!this._runHooks('beforeDelete', [table, ids])) return;
     await this._flush();
-    const r = safeJsonParse(wasmBindings.jsql_remove_by_ids(table, JSON.stringify(ids)));
+    const seqs = ids.map(id => this._seqIdByPk(table, id)).filter(s => s !== null);
+    const r = safeJsonParse(wasmBindings.jsql_remove_by_ids(table, JSON.stringify(seqs)));
     if (r && r.error) throw new Error(r.error);
-    this._emit('delete', { table, ids, result: r });
+    this._emit('delete', { table, ids: seqs, result: r });
     this._runHooks('afterDelete', [table, ids, r]);
     return r;
   }
@@ -476,7 +606,12 @@ class JSQL {
   async findByIds(table, ids) {
     await this._flush();
     if (!this._runHooks('beforeFind', [table, { ids }])) return null;
-    const r = safeJsonParse(wasmBindings.jsql_find_by_ids(table, JSON.stringify(ids)));
+    let r;
+    if (this._pkOf(table)) {
+      r = ids.map(id => this._findRawById(table, id)).filter(x => x !== null && !(x && x.error));
+    } else {
+      r = safeJsonParse(wasmBindings.jsql_find_by_ids(table, JSON.stringify(ids)));
+    }
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { ids }, r]);
     const schema = this._schemas[table];
@@ -491,7 +626,9 @@ class JSQL {
   async updateById(table, id, data) {
     if (!this._runHooks('beforeUpdate', [table, id, data])) return;
     await this._flush();
-    const r = safeJsonParse(wasmBindings.jsql_update_by_id(table, BigInt(id), JSON.stringify(data)));
+    const seq = this._seqIdByPk(table, id);
+    if (seq === null) return null;
+    const r = safeJsonParse(wasmBindings.jsql_update_by_id(table, BigInt(seq), JSON.stringify(data)));
     if (r && r.ok === false) throw new Error(r.error || 'update failed');
     this._emit('update', { table, id, data });
     this._runHooks('afterUpdate', [table, id, data, r]);
@@ -501,13 +638,53 @@ class JSQL {
   async removeById(table, id) {
     if (!this._runHooks('beforeDelete', [table, id])) return;
     await this._flush();
-    const r = safeJsonParse(wasmBindings.jsql_remove_by_id(table, BigInt(id)));
+    const seq = this._seqIdByPk(table, id);
+    if (seq === null) return null;
+    const r = safeJsonParse(wasmBindings.jsql_remove_by_id(table, BigInt(seq)));
     if (r && r.ok === false) throw new Error(r.error || 'remove failed');
     this._emit('delete', { table, id });
     this._runHooks('afterDelete', [table, id, r]);
     return r;
   }
 
+  async beginTx() {
+    await this._flush();
+    const r = safeJsonParse(wasmBindings.jsql_begin_tx());
+    if (r && r.ok === false) throw new Error(r.error || 'begin transaction failed');
+    this._txId = r.txId;
+    return r.txId;
+  }
+
+  async commitTx(txId) {
+    const r = safeJsonParse(wasmBindings.jsql_commit_tx(String(txId)));
+    if (r && r.ok === false) throw new Error(r.error || 'commit transaction failed');
+    return true;
+  }
+
+  async rollbackTx(txId) {
+    const r = safeJsonParse(wasmBindings.jsql_rollback_tx(String(txId)));
+    if (r && r.ok === false) throw new Error(r.error || 'rollback transaction failed');
+    return true;
+  }
+
+  async beginTransaction() {
+    return this.beginTx();
+  }
+
+  async commit() {
+    if (this._txId === undefined) return true;
+    const r = await this.commitTx(this._txId);
+    this._txId = undefined;
+    return r;
+  }
+
+  async rollback() {
+    if (this._txId === undefined) return true;
+    const r = await this.rollbackTx(this._txId);
+    this._txId = undefined;
+    return r;
+  }
+
   async hasTable(name) {
     return this._tableNames.has(name);
   }

package/lib/web_ui.js

@@ -111,7 +111,7 @@ load();
 
 class WebUI {
   constructor(opts = {}) {
-    this.port = opts.port || 8080;
+    this.port = opts.port !== undefined ? opts.port : 8080;
     this.dataDir = opts.dataDir || '.';
     this.readonly = !!opts.readonly;
     this.host = opts.host || '127.0.0.1';

package/nativesrc/jsql-neo-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsql-neo-core"
-version = "0.1.0"
+version = "5.4.0"
 edition = "2021"
 description = "Embedded database engine — core library (supports WASM)"
 

package/nativesrc/jsql-neo-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsql-neo-native"
-version = "0.1.0"
+version = "5.4.0"
 edition = "2021"
 
 [lib]

package/nativesrc/jsql-neo-wasm/Cargo.lock

@@ -171,7 +171,7 @@ dependencies = [
 
 [[package]]
 name = "jsql-neo-core"
-version = "0.1.0"
+version = "5.4.0"
 dependencies = [
  "bincode",
  "chrono",
@@ -187,7 +187,7 @@ dependencies = [
 
 [[package]]
 name = "jsql-neo-wasm"
-version = "0.1.0"
+version = "5.4.0"
 dependencies = [
  "js-sys",
  "jsql-neo-core",

package/nativesrc/jsql-neo-wasm/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "jsql-neo-wasm"
-version = "0.1.0"
+version = "5.4.0"
 edition = "2021"
 
 [lib]

package/nativesrc/jsql-neo-wasm/src/lib.rs

@@ -421,3 +421,27 @@ pub fn jsql_find_by_ids(table: &str, ids_json: &str) -> String {
         }
     })
 }
+
+#[wasm_bindgen]
+pub fn jsql_begin_tx() -> String {
+    ENGINE.with(|eng| match eng.borrow_mut().begin_tx() {
+        Ok(tx_id) => serde_json::json!({ "ok": true, "txId": tx_id }).to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}
+
+#[wasm_bindgen]
+pub fn jsql_commit_tx(tx_id: &str) -> String {
+    ENGINE.with(|eng| match eng.borrow_mut().commit_tx(tx_id) {
+        Ok(()) => r#"{"ok":true}"#.to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}
+
+#[wasm_bindgen]
+pub fn jsql_rollback_tx(tx_id: &str) -> String {
+    ENGINE.with(|eng| match eng.borrow_mut().rollback_tx(tx_id) {
+        Ok(()) => r#"{"ok":true}"#.to_string(),
+        Err(e) => format!(r#"{{"ok":false,"error":"{}"}}"#, e),
+    })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsql-neo",
-  "version": "5.3.1",
+  "version": "5.4.0",
   "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
   "main": "index.js",
   "types": "index.d.ts",
@@ -19,7 +19,6 @@
       "types": "./wasm/browser.d.ts",
       "default": "./wasm/browser.mjs"
     },
-    "./wasm/browser_bg.mjs": "./wasm/browser_bg.mjs",
     "./wasm/browser.d.ts": "./wasm/browser.d.ts",
     "./wasm/*": "./wasm/*",
     "./lib/*.js": "./lib/*.js",
@@ -48,8 +47,9 @@
     "postinstall": "node postinstall.js",
     "test": "node test/smoke.js",
     "test:btree": "node test/btree.test.js",
+    "test:native": "node test/native.test.js",
     "test:regress": "node test/regress-5.1.0.js",
-    "test:all": "node test/smoke.js && node test/coverage.js && node test/regress-5.1.0.js && node test/btree.test.js",
+    "test:all": "node test/smoke.js && node test/native.test.js && node test/wasm.test.js && node test/coverage.js && node test/regress-5.1.0.js && node test/join.test.js && node test/btree.test.js",
     "test:coverage": "c8 --all --include='lib/**' --exclude='lib/mysql_server.js' --exclude='lib/native_client.js' --exclude='lib/wasm_client.js' --exclude='lib/mysql_compat.js' --exclude='lib/nedb_compat.js' --exclude='lib/plugin.js' --reporter=text --reporter=lcov node test/coverage.js",
     "test:orms": "node examples/orms/run-all.js"
   },

package/test/join.test.js

@@ -0,0 +1,110 @@
+/*
+ * Regression tests for SQL JOIN null-fill correctness.
+ * Zero runtime dependencies (uses Node builtins + in-repo libs only).
+ *
+ *   node test/join.test.js
+ *
+ * Covers:
+ *   J1 LEFT JOIN unmatched rows null-fill right-table qualified columns
+ *   J2 RIGHT JOIN unmatched rows null-fill left-table qualified columns
+ *   J3 INNER JOIN unaffected
+ *   J4 unqualified column reference in JOIN
+ *   J5 WHERE filtering on the null-filled side
+ *   J6 self-join with table alias
+ *   J7 chained joins
+ */
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const Database = require(path.join(ROOT, 'lib/database'));
+const { executeSQL } = require(path.join(ROOT, 'lib/sql'));
+
+let passed = 0, failed = 0;
+function ok(name, cond, extra) {
+  if (cond) { passed++; console.log('[OK]', name); }
+  else { failed++; console.log('[FAIL]', name, extra !== undefined ? '-> ' + JSON.stringify(extra) : ''); }
+}
+
+async function setup(db) {
+  await executeSQL(db, 'CREATE TABLE a (id INT PRIMARY KEY, a_name STRING)');
+  await executeSQL(db, 'CREATE TABLE b (id INT PRIMARY KEY, a_id INT, b_name STRING)');
+  await executeSQL(db, "INSERT INTO a VALUES (1,'A1'),(2,'A2'),(3,'A3')");
+  await executeSQL(db, "INSERT INTO b VALUES (10,2,'B2'),(20,99,'B99')");
+}
+
+(async () => {
+  /* ============ J1 LEFT JOIN null-fill ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, 'SELECT a.id AS aid, a.a_name, b.id AS bid, b.b_name FROM a LEFT JOIN b ON a.id = b.a_id');
+    const row1 = r.rows[0]; // a=1 unmatched
+    ok('J1 left unmatched row', row1 && row1[0] === 1 && row1[1] === 'A1' && row1[2] === null && row1[3] === null, row1);
+    const row3 = r.rows[2]; // a=3 unmatched
+    ok('J1 second unmatched row', row3 && row3[0] === 3 && row3[2] === null, row3);
+    const row2 = r.rows[1]; // matched
+    ok('J1 matched row intact', row2 && row2[0] === 2 && row2[1] === 'A2' && row2[2] === 10 && row2[3] === 'B2', row2);
+  }
+
+  /* ============ J2 RIGHT JOIN null-fill ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, 'SELECT a.id AS aid, a.a_name, b.id AS bid, b.b_name FROM a RIGHT JOIN b ON a.id = b.a_id');
+    const b99 = r.rows[1]; // b=20 unmatched (a_id=99)
+    ok('J2 right unmatched row', b99 && b99[0] === null && b99[1] === null && b99[2] === 20 && b99[3] === 'B99', b99);
+    const b2 = r.rows[0]; // matched
+    ok('J2 matched row intact', b2 && b2[0] === 2 && b2[1] === 'A2' && b2[2] === 10 && b2[3] === 'B2', b2);
+  }
+
+  /* ============ J3 INNER JOIN ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, 'SELECT a.id AS aid, b.id AS bid FROM a INNER JOIN b ON a.id = b.a_id');
+    ok('J3 inner join', r.rows.length === 1 && r.rows[0][0] === 2 && r.rows[0][1] === 10, r.rows);
+  }
+
+  /* ============ J4 unqualified reference ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, 'SELECT a.id AS aid, b.b_name FROM a LEFT JOIN b ON a.id = b.a_id');
+    ok('J4 unprefixed id resolves to left table', r.rows[0][0] === 1 && r.rows[0][1] === null, r.rows[0]);
+  }
+
+  /* ============ J5 WHERE on null-filled side ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await setup(db);
+    const r = await executeSQL(db, "SELECT a.id AS aid, b.b_name FROM a LEFT JOIN b ON a.id = b.a_id WHERE b.id IS NULL");
+    ok('J5 left where b.id IS NULL', r.rows.length === 2 && r.rows.every(x => x[1] === null), r.rows);
+    const r2 = await executeSQL(db, "SELECT a.a_name, b.id AS bid FROM a RIGHT JOIN b ON a.id = b.a_id WHERE a.id IS NULL");
+    ok('J5 right where a.id IS NULL', r2.rows.length === 1 && r2.rows[0][0] === null && r2.rows[0][1] === 20, r2.rows);
+  }
+
+  /* ============ J6 self-join with alias ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await executeSQL(db, 'CREATE TABLE emp (id INT PRIMARY KEY, mgr_id INT, name STRING)');
+    await executeSQL(db, "INSERT INTO emp VALUES (1,NULL,'boss'),(2,1,'alice'),(3,999,'orphan')");
+    const r = await executeSQL(db, 'SELECT e.name AS ename, m.name AS mname FROM emp e LEFT JOIN emp m ON e.mgr_id = m.id');
+    ok('J6 self left join', r.rows.length === 3 && r.rows[0][0] === 'boss' && r.rows[0][1] === null && r.rows[1][1] === 'boss' && r.rows[2][1] === null, r.rows);
+  }
+
+  /* ============ J7 chained joins ============ */
+  {
+    const db = new Database(':memory:', { autoSave: false });
+    await executeSQL(db, 'CREATE TABLE a (id INT PRIMARY KEY, a_name STRING)');
+    await executeSQL(db, 'CREATE TABLE b (id INT PRIMARY KEY, a_id INT, b_name STRING)');
+    await executeSQL(db, 'CREATE TABLE c (id INT PRIMARY KEY, b_id INT, c_name STRING)');
+    await executeSQL(db, "INSERT INTO a VALUES (1,'A1'),(2,'A2'),(3,'A3')");
+    await executeSQL(db, "INSERT INTO b VALUES (10,2,'B2'),(20,99,'B99')");
+    await executeSQL(db, "INSERT INTO c VALUES (100,10,'C10'),(200,77,'C77')");
+    const r = await executeSQL(db, 'SELECT a.id AS aid, b.id AS bid, c.id AS cid, c.c_name FROM a LEFT JOIN b ON a.id = b.a_id LEFT JOIN c ON b.id = c.b_id');
+    ok('J7 chained left joins', r.rows.length === 3 && r.rows[1][1] === 10 && r.rows[1][2] === 100 && r.rows[1][3] === 'C10' && r.rows[0][1] === null && r.rows[0][2] === null, r.rows);
+  }
+
+  console.log(failed === 0 ? `\nALL ${passed} JOIN TESTS PASSED` : `\n${failed} FAILURES (${passed} passed)`);
+  process.exit(failed === 0 ? 0 : 1);
+})().catch((e) => { console.error('FATAL', e); process.exit(1); });