jsql-neo 5.3.0 → 5.4.0

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

package/test/native.test.js

@@ -0,0 +1,159 @@
+/*
+ * Native (.node N-API) regression tests
+ *   node test/native.test.js
+ * Covers: NativeJSQL CRUD + flat row shape, shorthand/snake_case schemas,
+ * disk persistence, and the better-sqlite3 compat layer on the native engine.
+ */
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const ROOT = path.join(__dirname, '..');
+
+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 () => {
+  const { JSQL } = require(path.join(ROOT, 'lib', 'native_client'));
+
+  /* ---------- basic CRUD + flat row shape ---------- */
+  {
+    const db = new JSQL();
+    await db.start();
+    await db.createTable('users', { id: 'integer primary key auto_increment', name: 'string', age: 'integer' });
+    const ids = await db.insert('users', [{ name: 'Alice', age: 30 }, { name: 'Bob', age: 25 }]);
+    ok('batch insert returns ids', Array.isArray(ids) && ids.length === 2, ids);
+
+    const row = db.findById('users', 1);
+    ok('findById returns flat row', row && row.id === 1 && row.name === 'Alice' && row.age === 30 && !('fields' in row), row);
+
+    const rows = await db.find('users', {});
+    ok('find returns flat rows', rows.length === 2 && rows[1].name === 'Bob' && rows[1].id === 2, rows);
+    ok('filter match', (await db.find('users', { age: 25 })).length === 1);
+    ok('filter no match', (await db.find('users', { age: 99 })).length === 0);
+    ok('count', (await db.count('users')) === 2);
+
+    db.updateByIds('users', [[1, { age: 99 }]]);
+    await new Promise(r => setTimeout(r, 150));
+    ok('updateByIds applied', db.findById('users', 1).age === 99, db.findById('users', 1));
+
+    db.removeByIds('users', [2]);
+    await new Promise(r => setTimeout(r, 150));
+    ok('removeByIds applied', (await db.count('users')) === 1, await db.count('users'));
+    await db.stop();
+  }
+
+  /* ---------- shorthand and snake_case schemas ---------- */
+  {
+    const db = new JSQL();
+    await db.start();
+    await db.createTable('t2', { name: 'string unique', n: 'number', ok: 'boolean' });
+    await db.insert('t2', { name: 'x', n: 1.5, ok: true });
+    const r2 = (await db.find('t2', {}))[0];
+    ok('shorthand schema fields', r2.name === 'x' && r2.n === 1.5 && r2.ok === true, r2);
+
+    await db.createTable('t3', { id: { type: 'integer', primary_key: true, auto_increment: true }, name: { type: 'string' } });
+    await db.insert('t3', { name: 'a' });
+    await db.insert('t3', { id: 7, name: 'b' });
+    ok('snake_case pk respected', db.findById('t3', 7).name === 'b', db.findById('t3', 7));
+    ok('explicit pk bumps next id', db.findById('t3', 1).name === 'a');
+
+    await db.createTable('cfg', 'key string primary key, value string');
+    const cfgIds = await db.insert('cfg', { key: 'a', value: '1' });
+    ok('full shorthand string schema', cfgIds[0] === 'a' && db.findById('cfg', 'a').value === '1', cfgIds);
+    await db.stop();
+  }
+
+  /* ---------- disk persistence roundtrip ---------- */
+  {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jsql-native-'));
+    const db = new JSQL({ path: dir, mode: 'disk' });
+    await db.start();
+    await db.createTable('p', { id: { type: 'integer', primaryKey: true, autoIncrement: true }, v: { type: 'string' } });
+    await db.insert('p', { v: 'persisted' });
+    await db.stop();
+    const db2 = new JSQL({ path: dir, mode: 'disk' });
+    await db2.start();
+    ok('tables restored', db2.getTables().includes('p'));
+    ok('rows persisted', (await db2.find('p', {}))[0].v === 'persisted', await db2.find('p', {}));
+    await db2.stop();
+  }
+
+  /* ---------- better-sqlite3 compat on native engine ---------- */
+  {
+    const Database = require(path.join(ROOT, 'lib', 'sqlite_compat'));
+    const db = new Database(':memory:', { engine: 'native' });
+    db.exec('CREATE TABLE t (id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING, age INTEGER)');
+    const r = db.prepare('INSERT INTO t (name, age) VALUES (?, ?)').run('a', 1);
+    ok('compat run returns changes', r.changes === 1 && r.lastInsertRowid === 1, r);
+    db.prepare('INSERT INTO t (name, age) VALUES (?, ?)').run('b', 2);
+    ok('compat select', db.prepare('SELECT * FROM t WHERE age = ?').get(1).name === 'a');
+    db.prepare('UPDATE t SET age = 99 WHERE name = ?').run('b');
+    ok('compat update', db.prepare('SELECT age FROM t WHERE name = ?').get('b').age === 99);
+    db.exec('BEGIN');
+    db.prepare('INSERT INTO t (name) VALUES (?)').run('tx');
+    db.exec('ROLLBACK');
+    ok('compat rollback', db.prepare('SELECT COUNT(*) AS n FROM t').get().n === 2);
+    const buf = db.serialize();
+    db.close();
+    const db2 = new Database(':memory:', { engine: 'native' });
+    db2.deserialize(buf);
+    ok('compat serialize roundtrip', db2.prepare('SELECT COUNT(*) AS n FROM t').get().n === 2);
+    db2.close();
+  }
+
+  /* ---------- non-auto pk: id resolution by pk value ---------- */
+  {
+    const db = new JSQL();
+    await db.start();
+    await db.createTable('config', { key: { type: 'string', primaryKey: true }, value: 'string' });
+    const ids = await db.insert('config', [{ key: 'a', value: '1' }, { key: 'b', value: '2' }]);
+    ok('non-auto pk insert returns pk values', JSON.stringify(ids) === JSON.stringify(['a', 'b']), ids);
+
+    const a = db.findById('config', 'a');
+    ok('findById resolves string pk', a && a.value === '1' && !('fields' in a), a);
+    ok('findById pk miss returns null', db.findById('config', 'nope') === null);
+
+    db.updateById('config', 'b', { value: '22' });
+    await new Promise(r => setTimeout(r, 150));
+    ok('updateById resolves string pk', db.findById('config', 'b').value === '22', db.findById('config', 'b'));
+
+    db.removeById('config', 'a');
+    await new Promise(r => setTimeout(r, 150));
+    ok('removeById resolves string pk', (await db.count('config')) === 1, await db.count('config'));
+
+    db.updateByIds('config', [['b', { value: '222' }]]);
+    await new Promise(r => setTimeout(r, 150));
+    ok('updateByIds resolves string pk', db.findById('config', 'b').value === '222', db.findById('config', 'b'));
+
+    db.removeByIds('config', ['b']);
+    await new Promise(r => setTimeout(r, 150));
+    ok('removeByIds resolves string pk', (await db.count('config')) === 0, await db.count('config'));
+    await db.stop();
+  }
+
+  /* ---------- transaction aliases (beginTransaction / rollback / commit) ---------- */
+  {
+    const db = new JSQL();
+    await db.start();
+    await db.createTable('tx', { id: 'integer primary key auto_increment', name: 'string' });
+    await db.insert('tx', { name: 'n1' });
+    await db.beginTransaction();
+    await db.insert('tx', { name: 'n2' });
+    await db.rollback();
+    ok('rollback reverts insert', (await db.count('tx')) === 1, await db.count('tx'));
+    await db.beginTransaction();
+    await db.insert('tx', { name: 'n3' });
+    await db.commit();
+    ok('commit keeps insert', (await db.count('tx')) === 2, await db.count('tx'));
+    await db.stop();
+  }
+
+  console.log(`\n${passed} passed, ${failed} failed`);
+  process.exit(failed ? 1 : 0);
+})().catch(e => {
+  console.error('[FATAL]', e.stack.split('\n').slice(0, 3).join('\n'));
+  process.exit(1);
+});

package/test/wasm.test.js

@@ -0,0 +1,111 @@
+/*
+ * WASM (.wasm) regression tests
+ *   node test/wasm.test.js
+ * Covers: JSQL CRUD + flat row shape, shorthand schemas, pk-aware by-id CRUD,
+ * non-auto pk insert backfill, and beginTransaction / rollback / commit.
+ */
+const path = require('path');
+const ROOT = path.join(__dirname, '..');
+
+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 () => {
+  const { JSQL } = require(path.join(ROOT, 'lib', 'wasm_client'));
+
+  /* ---------- basic CRUD + flat row shape ---------- */
+  {
+    const db = new JSQL({ modules: false });
+    await db.start();
+    await db.createTable('users', { id: 'integer primary key auto_increment', name: 'string', age: 'integer' });
+    const ids = await db.insert('users', [{ name: 'Alice', age: 30 }, { name: 'Bob', age: 25 }]);
+    ok('wasm batch insert returns ids', Array.isArray(ids) && ids.length === 2, ids);
+
+    const row = await db.findById('users', 1);
+    ok('wasm findById flat row', row && row.id === 1 && row.name === 'Alice' && !('fields' in row), row);
+
+    const rows = await db.find('users', {});
+    ok('wasm find returns flat rows', rows.length === 2 && rows[1].name === 'Bob', rows);
+    ok('wasm filter match', (await db.find('users', { age: 25 })).length === 1);
+    ok('wasm count', (await db.count('users')) === 2);
+
+    await db.updateById('users', 1, { age: 31 });
+    ok('wasm updateById applied', (await db.findById('users', 1)).age === 31, await db.findById('users', 1));
+
+    await db.updateByIds('users', [[2, { age: 99 }]]);
+    ok('wasm updateByIds applied', (await db.findById('users', 2)).age === 99, await db.findById('users', 2));
+
+    ok('wasm findByIds', (await db.findByIds('users', [1, 2])).length === 2);
+
+    await db.removeById('users', 1);
+    ok('wasm removeById applied', (await db.count('users')) === 1, await db.count('users'));
+
+    await db.removeByIds('users', [2]);
+    ok('wasm removeByIds applied', (await db.count('users')) === 0, await db.count('users'));
+    await db.stop();
+  }
+
+  /* ---------- non-auto pk: id resolution by pk value ---------- */
+  {
+    const db = new JSQL({ modules: false });
+    await db.start();
+    await db.createTable('config', { key: { type: 'string', primaryKey: true }, value: 'string' });
+    const ids = await db.insert('config', [{ key: 'a', value: '1' }, { key: 'b', value: '2' }]);
+    ok('wasm non-auto pk insert returns pk values', JSON.stringify(ids) === JSON.stringify(['a', 'b']), ids);
+
+    const a = await db.findById('config', 'a');
+    ok('wasm findById resolves string pk', a && a.value === '1' && !('fields' in a), a);
+    ok('wasm findById pk miss returns null', (await db.findById('config', 'nope')) === null);
+
+    await db.updateById('config', 'b', { value: '22' });
+    ok('wasm updateById resolves string pk', (await db.findById('config', 'b')).value === '22', await db.findById('config', 'b'));
+
+    await db.removeById('config', 'a');
+    ok('wasm removeById resolves string pk', (await db.count('config')) === 1, await db.count('config'));
+
+    await db.removeByIds('config', ['b']);
+    ok('wasm removeByIds resolves string pk', (await db.count('config')) === 0, await db.count('config'));
+    await db.stop();
+  }
+
+  /* ---------- shorthand schema ---------- */
+  {
+    const db = new JSQL({ modules: false });
+    await db.start();
+    await db.createTable('t2', { name: 'string unique', n: 'number', ok: 'boolean' });
+    await db.insert('t2', { name: 'x', n: 1.5, ok: true });
+    const r2 = (await db.find('t2', {}))[0];
+    ok('wasm shorthand schema fields', r2.name === 'x' && r2.n === 1.5 && r2.ok === true, r2);
+
+    await db.createTable('cfg', 'key string primary key, value string');
+    const cfgIds = await db.insert('cfg', { key: 'a', value: '1' });
+    ok('wasm full shorthand string schema', cfgIds[0] === 'a' && (await db.findById('cfg', 'a')).value === '1', cfgIds);
+    await db.stop();
+  }
+
+  /* ---------- transactions ---------- */
+  {
+    const db = new JSQL({ modules: false });
+    await db.start();
+    await db.createTable('tx', { id: 'integer primary key auto_increment', name: 'string' });
+    await db.insert('tx', { name: 'n1' });
+    await db.beginTransaction();
+    await db.insert('tx', { name: 'n2' });
+    await db.rollback();
+    ok('wasm rollback reverts insert', (await db.count('tx')) === 1, await db.count('tx'));
+    await db.beginTransaction();
+    await db.insert('tx', { name: 'n3' });
+    await db.commit();
+    ok('wasm commit keeps insert', (await db.count('tx')) === 2, await db.count('tx'));
+    await db.stop();
+  }
+
+  console.log(`\n${passed} passed, ${failed} failed`);
+  process.exit(failed ? 1 : 0);
+})().catch(e => {
+  console.error('[FATAL]', e.stack.split('\n').slice(0, 3).join('\n'));
+  process.exit(1);
+});

package/wasm/browser.d.ts

@@ -1,88 +1,89 @@
-/**
- * JSQL-NEO browser (WASM + IndexedDB) — ESM entry `jsql-neo/wasm/browser.mjs`.
- */
+/* tslint:disable */
+/* eslint-disable */
 
-export type FieldType =
-  | 'string' | 'integer' | 'float' | 'boolean' | 'date' | 'datetime' | 'timestamp'
-  | 'object' | 'array' | 'any';
-
-export interface FieldDef {
-  type: FieldType;
-  primaryKey?: boolean;
-  autoIncrement?: boolean;
-  unique?: boolean;
-  required?: boolean;
-  length?: number;
-  default?: unknown;
-  computed?: boolean;
-}
+export function jsql_begin_tx(): string;
 
-export type Schema = Record<string, FieldDef>;
+export function jsql_commit_tx(tx_id: string): string;
 
-export interface Row {
-  id: number | string;
-  fields?: Record<string, unknown>;
-  created_at?: string;
-  updated_at?: string;
-  [key: string]: unknown;
-}
+export function jsql_count(table: string): string;
 
-export interface FindOptions {
-  limit?: number;
-  offset?: number;
-}
+export function jsql_create_table(name: string, schema_json: string): string;
 
-export type JSQLHook =
-  | 'beforeInsert' | 'afterInsert'
-  | 'beforeUpdate' | 'afterUpdate'
-  | 'beforeDelete' | 'afterDelete'
-  | 'beforeFind' | 'afterFind'
-  | 'beforeCreateTable' | 'afterCreateTable'
-  | 'beforeDropTable' | 'afterDropTable'
-  | 'beforeFlush' | 'afterFlush'
-  | 'beforeCount' | 'afterCount'
-  | 'onStart' | 'onStop';
-
-export interface JSQLOptions {
-  dbName?: string;
-  persistence?: boolean;
-  flushThreshold?: number;
-  pageSize?: number;
-}
+export function jsql_drop_table(name: string): string;
+
+export function jsql_find(table: string, filter_json: string, limit: number, offset: number): string;
+
+export function jsql_find_by_id(table: string, id: bigint): string;
+
+export function jsql_find_by_ids(table: string, ids_json: string): string;
+
+export function jsql_insert(table: string, data_json: string): string;
+
+export function jsql_insert_buf(table: string, data: Uint8Array): string;
+
+export function jsql_insert_buf_count(table: string, data: Uint8Array): string;
+
+export function jsql_insert_json(table: string, json: string): string;
 
-export class JSQL {
-  constructor(opts?: JSQLOptions);
-  on(event: JSQLHook, fn: (...args: any[]) => unknown): this;
-  onEvent(fn: (event: string, data: unknown) => void): this;
-  start(): Promise<void>;
-  stop(): Promise<void>;
-  flush(): Promise<void>;
-  createTable(name: string, schema: Schema): Promise<unknown>;
-  dropTable(name: string): Promise<unknown>;
-  insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<unknown>;
-  findById(table: string, id: number | string): Promise<Row | null>;
-  findByIds(table: string, ids: Array<number | string>): Promise<Row[] | null>;
-  find(table: string, filter?: Record<string, unknown>, opts?: FindOptions): Promise<Row[]>;
-  count(table: string): Promise<number>;
-  updateById(table: string, id: number | string, data: Record<string, unknown>): Promise<unknown>;
-  updateByIds(table: string, entries: Array<[number | string, Record<string, unknown>]>): Promise<unknown>;
-  removeById(table: string, id: number | string): Promise<unknown>;
-  removeByIds(table: string, ids: Array<number | string>): Promise<unknown>;
-  hasTable(name: string): Promise<boolean>;
-  getTables(): Promise<string[]>;
-  getTableSchema(name: string): Promise<Schema | null>;
-  beginTx(): Promise<void>;
-  commitTx(): Promise<void>;
-  rollbackTx(): Promise<void>;
-  begin(): Promise<void>;
-  commit(): Promise<void>;
-  rollback(): Promise<void>;
-  listDatabases(): Promise<string[]>;
-  createDatabase(name: string): Promise<void>;
-  dropDatabase(name: string): Promise<void>;
-  useDatabase(name: string): Promise<void>;
-  executeSQL(sql: string, params?: unknown[]): Promise<unknown>;
-  export default?: never;
+export function jsql_remove_by_id(table: string, id: bigint): string;
+
+export function jsql_remove_by_ids(table: string, ids_json: string): string;
+
+export function jsql_reset(): void;
+
+export function jsql_rollback_tx(tx_id: string): string;
+
+export function jsql_update_by_id(table: string, id: bigint, data_json: string): string;
+
+export function jsql_update_by_ids(table: string, batch_json: string): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly jsql_begin_tx: () => [number, number];
+    readonly jsql_commit_tx: (a: number, b: number) => [number, number];
+    readonly jsql_count: (a: number, b: number) => [number, number];
+    readonly jsql_create_table: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly jsql_drop_table: (a: number, b: number) => [number, number];
+    readonly jsql_find: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+    readonly jsql_find_by_id: (a: number, b: number, c: bigint) => [number, number];
+    readonly jsql_find_by_ids: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly jsql_insert: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly jsql_insert_buf: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly jsql_insert_buf_count: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly jsql_insert_json: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly jsql_remove_by_id: (a: number, b: number, c: bigint) => [number, number];
+    readonly jsql_remove_by_ids: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly jsql_rollback_tx: (a: number, b: number) => [number, number];
+    readonly jsql_update_by_id: (a: number, b: number, c: bigint, d: number, e: number) => [number, number];
+    readonly jsql_update_by_ids: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly jsql_reset: () => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
 }
 
-export function init(input?: Uint8Array | ArrayBuffer | Response | WebAssembly.Module | URL | string): Promise<JSQL | void>;
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;