jsql-neo 5.3.0 → 5.4.0

package/lib/query.js

@@ -537,7 +537,7 @@ class Query {
                 const key = fr[join.foreignField];
                 const matches = localRows.filter(lr => lr[join.localField] === key);
                 if (matches.length === 0) {
-                    result.push({ ...fr, ...this._nullRow(join, true) });
+                    result.push(this._rightNullRow(localRows, fr, join));
                 } else {
                     for (const lr of matches) {
                         result.push(this._mergeJoinRow(lr, fr, join));
@@ -582,7 +582,7 @@ class Query {
             for (const fr of foreignRows) {
                 const matches = localRows.filter(lr => lr[join.localField] === fr[join.foreignField]);
                 if (matches.length === 0) {
-                    result.push({ ...fr, ...this._nullRow(join, true) });
+                    result.push(this._rightNullRow(localRows, fr, join));
                 } else {
                     for (const lr of matches) {
                         result.push(this._mergeJoinRow(lr, fr, join));
@@ -621,6 +621,24 @@ class Query {
         return nulls;
     }
 
+    /**
+     * RIGHT JOIN 未匹配右表行：保留右表数据，本地表字段填 null。
+     * 返回 { localNulls, merged }，其中 merged = { ...nulls, ...fr }
+     */
+    _rightNullRow(localRows, foreignRow, join) {
+        const localSchema = this._table._schema || {};
+        const localNulls = {};
+        for (const field of Object.keys(localSchema)) {
+            if (field !== '_softDelete') localNulls[field] = null;
+        }
+        const prefix = join.as ? join.as + '_' : '';
+        const foreignPrefixed = {};
+        for (const [key, value] of Object.entries(foreignRow)) {
+            foreignPrefixed[prefix + key] = value;
+        }
+        return { ...localNulls, ...foreignPrefixed };
+    }
+
     // ============================================================
     // 内部: 排序
     // ============================================================

package/lib/sql.js

@@ -261,12 +261,18 @@ class Parser {
     if (this.peek().type === 'op' && this.peek().value === '.') {
       this.next();
       const t2 = this.next();
-      if (t2.type !== 'ident') throw new Error(`Expected table name after '.', got '${t2.value}'`);
+      if (t2.type !== 'ident' && !(t2.type === 'keyword' && this._isSchemaView(t2.value))) {
+        throw new Error(`Expected table name after '.', got '${t2.value}'`);
+      }
       return t.value + '.' + t2.value;
     }
     return t.value;
   }
 
+  _isSchemaView(v) {
+    return ['TABLES', 'COLUMNS', 'SCHEMATA', 'STATISTICS', 'KEY_COLUMN_USAGE', 'REFERENTIAL_CONSTRAINTS', 'TABLE_CONSTRAINTS', 'VIEWS'].includes(String(v).toUpperCase());
+  }
+
   parseCreateTable() {
     this.expectKeyword('CREATE');
     this.expectKeyword('TABLE');
@@ -1870,11 +1876,12 @@ class SQLExecutor {
         const schema = this.engine.getTableSchema
           ? await this.engine.getTableSchema(statement.table)
           : (this.engine._schemas ? this.engine._schemas[statement.table] : null);
+        const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         let count = 0;
         for (const row of all) {
           if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
-            const id = row._rid !== undefined ? row._rid : row.id;
+            const id = this._rowPkId(row, pkCols);
             if (id !== undefined) {
               const data = {};
               for (const [col, val] of statement.assignments) {
@@ -1892,11 +1899,12 @@ class SQLExecutor {
         const schema = this.engine.getTableSchema
           ? await this.engine.getTableSchema(statement.table)
           : (this.engine._schemas ? this.engine._schemas[statement.table] : null);
+        const pkCols = schema ? Object.keys(schema).filter(k => schema[k].primaryKey) : [];
         const all = (await this.engine.find(statement.table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
         const ids = [];
         for (const row of all) {
           if (!statement.where || evaluateExpr(statement.where, row, this.ctx)) {
-            const id = row._rid !== undefined ? row._rid : row.id;
+            const id = this._rowPkId(row, pkCols);
             if (id !== undefined) ids.push(id);
           }
         }
@@ -2166,6 +2174,19 @@ class SQLExecutor {
     return schema;
   }
 
+  /**
+   * 取行的行 ID：优先内部 _rid，否则用实际主键字段值（不再硬编码 id）。
+   */
+  _rowPkId(row, pkCols) {
+    if (row && row._rid !== undefined) return row._rid;
+    if (pkCols.length > 0) {
+      for (const c of pkCols) {
+        if (row[c] !== undefined && row[c] !== null) return row[c];
+      }
+    }
+    return row ? row.id : undefined;
+  }
+
   async _readTable(table) {
     const schema = await this._getSchema(table);
     const rows = (await this.engine.find(table, {}, { limit: 1e9, offset: 0 })).map(r => normalizeRow(r, schema));
@@ -2366,6 +2387,19 @@ class SQLExecutor {
     return out;
   }
 
+  /**
+   * 生成对端表的前缀 null 行：仅含 `prefix.col` 键（值为 null），
+   * 用于 JOIN 未匹配行补齐限定列，避免回退到未前缀副本拿错值。
+   */
+  _nullPrefixedRow(schema, prefix) {
+    const out = {};
+    for (const k of Object.keys(schema)) {
+      if (k === '_softDelete') continue;
+      out[prefix + '.' + k] = null;
+    }
+    return out;
+  }
+
   _aggValue(rows, fn, column) {
     if (fn === 'COUNT') return rows.length;
     const op = typeof column === 'string' ? { type: 'column', name: column } : column;
@@ -2445,6 +2479,7 @@ class SQLExecutor {
 
     let schema = null;
     let all;
+    let rowsAll;
     if (!statement.from) {
       // 无 FROM：虚拟行（SELECT 1, 'a'）
       all = [{ _virtual: true }];
@@ -2469,7 +2504,6 @@ class SQLExecutor {
         const rows = filtered.map(r => outCols.map(c => (c in r ? r[c] : null)));
         return { ok: true, type: 'select', table: firstItem.table, columns: outCols, rows, raw: filtered };
       }
-      let rowsAll;
       if (firstItem.subquery) {
         const res = await this.executeSelect(firstItem.subquery);
         rowsAll = { rows: this._subQueryRows(res), schema: null, columns: res.columns };
@@ -2495,6 +2529,10 @@ class SQLExecutor {
         }
         const matched = [];
         const unmatchedRight = new Set(rightRows.map((r, i) => i));
+        // 未匹配行补对端表的前缀 null 列：限定列名（如 a.id / b.id）按前缀解析，
+        // 避免回退到未前缀副本拿到错误值。
+        const rightNulls = (rightRes.schema) ? this._nullPrefixedRow(rightRes.schema, rightPrefix) : null;
+        const leftNulls = (rowsAll && rowsAll.schema) ? this._nullPrefixedRow(rowsAll.schema, firstPrefix) : null;
         rows.forEach(l => {
           let m = null;
           for (let ri = 0; ri < rightRows.length; ri++) {
@@ -2507,11 +2545,11 @@ class SQLExecutor {
             matched.push({ ...l, ...rightRows[m] });
             unmatchedRight.delete(m);
           } else if (j.type === 'left') {
-            matched.push({ ...l });
+            matched.push(rightNulls ? { ...rightNulls, ...l } : { ...l });
           }
         });
         if (j.type === 'right') {
-          for (const ri of unmatchedRight) matched.push({ ...rightRows[ri] });
+          for (const ri of unmatchedRight) matched.push(leftNulls ? { ...leftNulls, ...rightRows[ri] } : { ...rightRows[ri] });
         }
         rows = matched;
       }

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/table.js

@@ -242,6 +242,23 @@ class Table {
         const schema = this._schema;
         const checkConstraints = this._checkConstraints;
         const foreignKeys = this._foreignKeys;
+        // 批量预分配自增 ID 范围：先扫描显式提供的最大值，一次性推进计数器，
+        // 再在循环内用本地序号递增，避免批量内重复读取/写入同一计数器字段。
+        const baseAutoInc = this._autoIncrement;
+        if (autoIncField) {
+            let maxExplicit = 0;
+            for (const it of items) {
+                const v = it[autoIncField];
+                if (v !== undefined && v !== null) {
+                    const n = Number(v);
+                    if (!isNaN(n) && n > maxExplicit) maxExplicit = n;
+                }
+            }
+            if (maxExplicit > baseAutoInc) {
+                this._autoIncrement = maxExplicit;
+            }
+        }
+        let autoIncSeq = 0;
         for (let i = 0; i < N; i++) {
             let data = items[i];
             for (const [f, dv] of Object.entries(defaults)) {
@@ -279,8 +296,9 @@ class Table {
                 }
             }
             if (autoIncField && data[autoIncField] === undefined) {
-                this._autoIncrement++;
-                data[autoIncField] = this._autoIncrement;
+                autoIncSeq++;
+                data[autoIncField] = baseAutoInc + autoIncSeq;
+                this._autoIncrement = data[autoIncField];
             } else if (autoIncField && data[autoIncField] > this._autoIncrement) {
                 this._autoIncrement = data[autoIncField];
             }

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.0",
+  "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"
   },