jsql-neo 5.3.1 → 5.4.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>;