jsql-neo 5.3.1 → 5.4.1

package/lib/native_client.js

@@ -30,14 +30,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' };
     }
@@ -46,25 +84,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;
@@ -154,6 +213,7 @@ class JSQL {
     this._opFlushInterval = opts.opFlushInterval || 50;
     this._tableNames = new Set();
     this._schemas = {};
+    this._txId = undefined;
     this._autoPlugins = opts.modules !== false;
 
     // 持久化模式: 'memory' | 'hybrid' | 'disk'
@@ -313,6 +373,62 @@ class JSQL {
     }
   }
 
+  _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 = safeParse(native.jsqlFind(table, JSON.stringify(filter), 1, 0));
+      if (r && r.error) return r;
+      return Array.isArray(r) && r.length > 0 ? r[0] : null;
+    }
+    return safeParse(native.jsqlFindById(table, Number(id)));
+  }
+
+  _seqIdByPk(table, id) {
+    const pk = this._pkOf(table);
+    if (pk) {
+      const filter = {};
+      filter[pk] = this._coercePkId(table, id);
+      const r = safeParse(native.jsqlFind(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) {
@@ -328,6 +444,15 @@ class JSQL {
     const bin = encodeBatch(rows);
     const r = safeParse(native.jsqlInsertBuf(table, bin));
     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;
   }
 
@@ -419,7 +544,7 @@ class JSQL {
     const r = safeParse(native.jsqlCreateTable(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;
@@ -440,7 +565,7 @@ class JSQL {
   findById(table, id) {
     this._flushOpsNow();
     if (!this._runHooks('beforeFind', [table, { id }])) return null;
-    const raw = safeParse(native.jsqlFindById(table, Number(id)));
+    const raw = this._findRawById(table, id);
     if (raw && raw.error) throw new Error(raw.error);
     this._runHooks('afterFind', [table, { id }, raw]);
     const schema = this._schemas[table];
@@ -451,8 +576,12 @@ class JSQL {
   findByIds(table, ids) {
     this._flushOpsNow();
     if (!this._runHooks('beforeFind', [table, { ids }])) return null;
-    const resultStr = native.jsqlFindByIds(table, JSON.stringify(ids));
-    const r = safeParse(resultStr);
+    let r;
+    if (this._pkOf(table)) {
+      r = ids.map(id => this._findRawById(table, id)).filter(x => x !== null && !(x && x.error));
+    } else {
+      r = safeParse(native.jsqlFindByIds(table, JSON.stringify(ids)));
+    }
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { ids }, r]);
     const schema = this._schemas[table];
@@ -487,7 +616,11 @@ class JSQL {
   }
 
   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;
     if (!this._opBuffer.update[table]) this._opBuffer.update[table] = [];
     this._opBuffer.update[table].push(...pairs);
@@ -497,21 +630,28 @@ class JSQL {
   removeByIds(table, ids) {
     if (!this._runHooks('beforeDelete', [table, ids])) return;
     if (!this._opBuffer.remove[table]) this._opBuffer.remove[table] = new Set();
-    for (const id of ids) this._opBuffer.remove[table].add(Number(id));
+    for (const id of ids) {
+      const seq = this._seqIdByPk(table, id);
+      if (seq !== null) this._opBuffer.remove[table].add(seq);
+    }
     this._scheduleOpFlush();
   }
 
   updateById(table, id, data) {
     if (!this._runHooks('beforeUpdate', [table, id, data])) return;
+    const seq = this._seqIdByPk(table, id);
+    if (seq === null) return;
     if (!this._opBuffer.update[table]) this._opBuffer.update[table] = [];
-    this._opBuffer.update[table].push([Number(id), data]);
+    this._opBuffer.update[table].push([seq, data]);
     this._scheduleOpFlush();
   }
 
   removeById(table, id) {
     if (!this._runHooks('beforeDelete', [table, id])) return;
+    const seq = this._seqIdByPk(table, id);
+    if (seq === null) return;
     if (!this._opBuffer.remove[table]) this._opBuffer.remove[table] = new Set();
-    this._opBuffer.remove[table].add(Number(id));
+    this._opBuffer.remove[table].add(seq);
     this._scheduleOpFlush();
   }
 
@@ -543,9 +683,28 @@ class JSQL {
     this._flushOpsNow();
     const r = safeParse(native.jsqlBeginTx());
     if (r && r.ok === false) throw new Error(r.error || 'begin transaction failed');
+    this._txId = r.txId;
     return r.txId;
   }
 
+  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 commitTx(txId) {
     const r = safeParse(native.jsqlCommitTx(String(txId)));
     if (r && r.ok === false) throw new Error(r.error || 'commit transaction failed');

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);
   }