npm - jsql-neo - Versions diffs - 4.2.0 → 4.4.0 - Mend

jsql-neo 4.2.0 → 4.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/lib/table.js CHANGED Viewed

@@ -255,7 +255,8 @@ class Table {
             }
             for (const field of this._cachedSchemaFields) {
                 const def = schema[field];
-                if (def.required && (data[field] === undefined || data[field] === null)) throw createError('ER_BAD_NULL_ERROR', field);
+                if (def.required && (data[field] === undefined || data[field] === null)
+                    && !(def.autoIncrement && data[field] === undefined)) throw createError('ER_BAD_NULL_ERROR', field);
                 if (def.unique && data[field] !== undefined) {
                     if (uniqueTracker[field].has(data[field])) throw createError('ER_DUP_ENTRY', String(data[field]), field);
                     uniqueTracker[field].add(data[field]);
@@ -986,7 +987,8 @@ class Table {
             if (field === '_softDelete') continue;
             // NOT NULL
-            if (def.required && (data[field] === undefined || data[field] === null)) {
+            if (def.required && (data[field] === undefined || data[field] === null)
+                && !(def.autoIncrement && data[field] === undefined)) {
                 throw createError('ER_BAD_NULL_ERROR', field);
             }

package/lib/web_ui.js ADDED Viewed

@@ -0,0 +1,226 @@
+/*
+ * JSQL-NEO built-in web UI: zero-dependency HTTP management console.
+ *
+ *   const { WebUI } = require('jsql-neo');
+ *   const ui = new WebUI({ port: 8080, dataDir: './data' });
+ *   await ui.start();
+ *
+ * Routes:
+ *   GET  /                       management console (HTML, no external deps)
+ *   GET  /api/databases          [{name, tables, rows}]
+ *   GET  /api/tables?db=name     {tables: [{name, count}]}
+ *   POST /api/query  {db, sql}   {columns, rows, rowCount, ok, error?}
+ */
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const Database = require('./database');
+const { executeSQL } = require('./sql');
+const PAGE = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>JSQL-NEO</title>
+<style>
+:root { color-scheme: dark; }
+body { margin: 0; font: 14px/1.5 ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; background: #0d1117; color: #e6edf3; display: flex; height: 100vh; }
+.side { width: 260px; border-right: 1px solid #21262d; padding: 12px; overflow: auto; }
+.main { flex: 1; display: flex; flex-direction: column; }
+h1 { font-size: 15px; margin: 4px 0 12px; }
+h2 { font-size: 12px; color: #8b949e; text-transform: uppercase; letter-spacing: 1px; margin: 14px 0 6px; }
+.db { cursor: pointer; padding: 3px 6px; border-radius: 6px; }
+.db:hover, .db.active { background: #1f6feb33; }
+.db .rows { color: #8b949e; font-size: 12px; }
+.tbl { cursor: pointer; padding: 2px 6px 2px 18px; color: #79c0ff; border-radius: 4px; }
+.tbl:hover { background: #21262d; }
+textarea { flex: 1; margin: 12px; padding: 10px; background: #010409; color: #e6edf3; border: 1px solid #21262d; border-radius: 8px; resize: none; font: inherit; }
+.actions { padding: 0 12px; }
+button { background: #238636; border: 0; color: #fff; padding: 6px 16px; border-radius: 6px; cursor: pointer; font: inherit; }
+button:hover { background: #2ea043; }
+button:disabled { background: #21262d; cursor: wait; }
+.status { padding: 0 12px 10px; color: #8b949e; min-height: 20px; }
+table { border-collapse: collapse; width: 100%; font-size: 13px; }
+th, td { border: 1px solid #21262d; padding: 4px 8px; text-align: left; white-space: pre; }
+th { background: #161b22; position: sticky; top: 0; }
+tr:nth-child(even) td { background: #0d1117; }
+.result { flex: 1.4; overflow: auto; margin: 0 12px 12px; border: 1px solid #21262d; border-radius: 8px; background: #010409; }
+.err { color: #f85149; padding: 10px; }
+.ok { color: #3fb950; }
+</style>
+</head>
+<body>
+<div class="side">
+  <h1>JSQL-NEO</h1>
+  <h2>Databases</h2>
+  <div id="dbs"></div>
+  <h2>Tables</h2>
+  <div id="tbls"></div>
+</div>
+<div class="main">
+  <textarea id="sql" spellcheck="false" placeholder="SELECT * FROM t LIMIT 100">SELECT 1</textarea>
+  <div class="actions">
+    <button id="run" onclick="run()">Run (Ctrl+Enter)</button>
+  </div>
+  <div class="status" id="status"></div>
+  <div class="result" id="res"></div>
+</div>
+<script>
+let dbs = [], cur = null;
+const q = async (u, o) => { const r = await fetch(u, o); return r.json(); };
+function esc(s) { return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;'); }
+async function load() {
+  dbs = await q('/api/databases');
+  const el = document.getElementById('dbs');
+  el.innerHTML = dbs.map(d => '<div class="db" onclick="openDb(' + esc(d.name) + ')">' + esc(d.name) + ' <span class="rows">(' + d.tables + ' tbl)</span></div>').join('');
+  if (!cur && dbs.length) openDb(dbs[0].name);
+}
+async function openDb(n) {
+  cur = n;
+  document.querySelectorAll('.db').forEach(e => e.classList.toggle('active', e.textContent.indexOf(n) === 0));
+  const r = await q('/api/tables?db=' + encodeURIComponent(n));
+  document.getElementById('tbls').innerHTML = r.tables.map(t =>
+    '<div class="tbl" onclick="sel(' + esc(t.name) + ')">' + esc(t.name) + ' (' + t.count + ')</div>').join('');
+}
+function sel(n) { document.getElementById('sql').value = 'SELECT * FROM ' + n + ' LIMIT 100'; run(); }
+async function run() {
+  const sql = document.getElementById('sql').value;
+  if (!cur || !sql.trim()) return;
+  const btn = document.getElementById('run'); btn.disabled = true;
+  const st = document.getElementById('status'); st.innerHTML = 'running...';
+  try {
+    const r = await q('/api/query', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ db: cur, sql }) });
+    st.innerHTML = r.ok ? '<span class="ok">ok</span> ' + r.rowCount + ' row(s), ' + r.ms + 'ms' : '<span class="err">' + esc(r.error) + '</span>';
+    if (r.columns && r.columns.length) {
+      let h = '<table><tr>' + r.columns.map(c => '<th>' + esc(c) + '</th>').join('') + '</tr>';
+      h += r.rows.map(row => '<tr>' + row.map(c => '<td>' + (c === null ? '<i>NULL</i>' : esc(c)) + '</td>').join('') + '</tr>').join('');
+      document.getElementById('res').innerHTML = h + '</table>';
+    } else if (r.affected !== undefined) {
+      document.getElementById('res').innerHTML = '<p class="ok">' + r.affected + ' row(s) affected</p>';
+    }
+  } catch (e) { st.innerHTML = '<span class="err">' + esc(e.message) + '</span>'; }
+  btn.disabled = false;
+}
+document.addEventListener('keydown', e => { if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') run(); });
+load();
+</script>
+</body>
+</html>
+`;
+class WebUI {
+  constructor(opts = {}) {
+    this.port = opts.port || 8080;
+    this.dataDir = opts.dataDir || '.';
+    this.readonly = !!opts.readonly;
+    this.host = opts.host || '0.0.0.0';
+    this.cache = new Map();
+  }
+  dbPath(name) {
+    if (!/^[A-Za-z0-9_.-]+$/.test(name)) throw new Error('invalid database name');
+    const p = path.join(this.dataDir, name + '.json');
+    if (!fs.existsSync(p)) throw new Error('database not found: ' + name);
+    return p;
+  }
+  async db(name) {
+    if (this.cache.has(name)) return this.cache.get(name);
+    const db = new Database(this.dbPath(name), { autoSave: !this.readonly });
+    if (db.loadDatabase) await db.loadDatabase();
+    this.cache.set(name, db);
+    return db;
+  }
+  listDatabases() {
+    if (!fs.existsSync(this.dataDir)) return [];
+    return fs.readdirSync(this.dataDir)
+      .filter(f => f.endsWith('.json'))
+      .map(f => {
+        let tables = 0;
+        try { tables = Object.keys(JSON.parse(fs.readFileSync(path.join(this.dataDir, f), 'utf8')).__schema__ || {}).length; } catch (_) {}
+        return { name: f.slice(0, -5), tables };
+      });
+  }
+  tableList(db) {
+    const map = db._tables || {};
+    return Object.values(map).map(t => ({
+      name: t._name || t.name,
+      count: (t._rows || t.rows || []).length,
+    }));
+  }
+  async handle(req, res) {
+    const url = new URL(req.url, 'http://x');
+    const send = (code, obj) => {
+      const body = JSON.stringify(obj);
+      res.writeHead(code, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' });
+      res.end(body);
+    };
+    try {
+      if (url.pathname === '/' && req.method === 'GET') {
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        return res.end(PAGE);
+      }
+      if (url.pathname === '/api/databases' && req.method === 'GET') {
+        return send(200, this.listDatabases());
+      }
+      if (url.pathname === '/api/tables' && req.method === 'GET') {
+        const db = await this.db(url.searchParams.get("db"));
+        return send(200, { tables: this.tableList(db) });
+      }
+      if (url.pathname === '/api/query' && req.method === 'POST') {
+        let body = '';
+        for await (const chunk of req) body += chunk;
+        const { db: dbName, sql } = JSON.parse(body || '{}');
+        if (!dbName || !sql) return send(400, { ok: false, error: 'db and sql are required' });
+        const db = await this.db(dbName);
+        const t0 = Date.now();
+        try {
+          const res2 = await executeSQL(db, sql);
+          const ms = Date.now() - t0;
+          const out = { ok: true, ms };
+          if (res2 && res2.rows) {
+            out.columns = res2.columns;
+            out.rows = res2.rows;
+            out.rowCount = res2.rows.length;
+          } else if (res2 && res2.affectedRows !== undefined) {
+            out.affected = res2.affectedRows;
+          } else {
+            out.rowCount = 0;
+          }
+          return send(200, out);
+        } catch (e) {
+          return send(200, { ok: false, error: String(e.message || e) });
+        }
+      }
+      return send(404, { ok: false, error: 'not found' });
+    } catch (e) {
+      return send(500, { ok: false, error: String(e.message || e) });
+    }
+  }
+  start() {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => this.handle(req, res).catch(e => {
+        try { res.writeHead(500, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ ok: false, error: String(e.message || e) })); } catch (_) {}
+      }));
+      this.server.on('error', reject);
+      this.server.listen(this.port, this.host, () => resolve(this.server.address().port));
+    });
+  }
+  stop() {
+    return new Promise(resolve => {
+      for (const db of this.cache.values()) db.stop();
+      this.cache.clear();
+      if (this.server) this.server.close(() => resolve());
+      else resolve();
+    });
+  }
+}
+module.exports = { WebUI };

package/package.json CHANGED Viewed

@@ -1,51 +1,70 @@
 {
-    "name": "jsql-neo",
-    "version": "4.2.0",
-    "description": "JSQL-NEO — Rust-powered embedded database with WASM, REST API, B-Tree indexes, WAL, crash recovery",
-    "main": "index.js",
-    "bin": {
-        "jsql": "./bin/jsql"
+  "name": "jsql-neo",
+  "version": "4.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",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "browser": "./wasm/browser.mjs",
+      "default": "./index.js"
     },
-    "files": [
-        "index.js",
-        "lib/",
-        "bin/",
-        "wasm/",
-        "native/",
-        "nativesrc/",
-        "!nativesrc/**/target/",
-        "postinstall.js",
-        "README.md",
-        "LICENSE"
-    ],
-    "scripts": {
-        "postinstall": "node postinstall.js"
+    "./wasm/browser.mjs": {
+      "types": "./wasm/browser.d.ts",
+      "default": "./wasm/browser.mjs"
     },
-    "keywords": [
-        "database",
-        "sql",
-        "embedded",
-        "rust",
-        "wasm",
-        "json",
-        "javascript",
-        "jsql",
-        "nosql",
-        "rest-api",
-        "high-performance"
-    ],
-    "author": "Vexify",
-    "license": "Apache-2.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/vexify-org/JSQL-neo.git"
-    },
-    "bugs": "https://github.com/vexify-org/JSQL-neo/issues",
-    "homepage": "https://github.com/vexify-org/JSQL-neo#readme",
-    "engines": {
-        "node": ">=14.0.0"
-    },
-    "dependencies": {
-        "@vexify-org/yaggs": "^8.1.0"
-    }
+    "./wasm/*": "./wasm/*",
+    "./lib/*": "./lib/*",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "jsql": "./bin/jsql"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "lib/",
+    "bin/",
+    "wasm/",
+    "native/",
+    "nativesrc/",
+    "!nativesrc/**/target/",
+    "postinstall.js",
+    "test/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node postinstall.js",
+    "test": "node test/smoke.js",
+    "test:orms": "node examples/orms/run-all.js"
+  },
+  "keywords": [
+    "database",
+    "sql",
+    "embedded",
+    "rust",
+    "wasm",
+    "json",
+    "javascript",
+    "jsql",
+    "nosql",
+    "rest-api",
+    "high-performance"
+  ],
+  "author": "Vexify",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vexify-org/JSQL-neo.git"
+  },
+  "bugs": "https://github.com/vexify-org/JSQL-neo/issues",
+  "homepage": "https://github.com/vexify-org/JSQL-neo#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "dependencies": {
+    "@vexify-org/yaggs": "^8.1.0"
+  }
 }

package/test/smoke.js ADDED Viewed

@@ -0,0 +1,58 @@
+/*
+ * Zero-dependency smoke test for the SQL engine core.
+ *   npm test   (or: node test/smoke.js)
+ */
+const { executeSQL, parseSQL, applyParams } = require('../lib/sql.js');
+const { createMysqlServer } = require('../lib/mysql_server.js');
+let pass = 0, fail = 0;
+const ok = (name, cond, extra) => {
+  if (cond) { pass++; console.log('[OK]', name); }
+  else { fail++; console.log('[FAIL]', name, extra !== undefined ? '→ ' + JSON.stringify(extra) : ''); }
+};
+const engine = {
+  hasTable: () => true,
+  truncate: async () => {},
+  flush: async () => {},
+  find: async () => [
+    { id: 1, name: 'A', age: 30 },
+    { id: 2, name: 'B', age: 40 },
+    { id: 3, name: 'C', age: 25 },
+  ],
+  getTableSchema: async () => ({
+    id: { type: 'integer', primaryKey: true },
+    name: { type: 'string' },
+    age: { type: 'integer' },
+  }),
+};
+(async () => {
+  const opts = { safety: false };
+  const agg = await executeSQL(engine, 'SELECT COUNT(*) AS n, MAX(age) AS m, SUM(age) AS s, AVG(age) AS a FROM users', opts);
+  ok('multi-aggregate SELECT returns all columns', JSON.stringify(agg.columns) === JSON.stringify(['n', 'm', 's', 'a'])
+    && JSON.stringify(agg.rows[0]) === JSON.stringify([3, 40, 95, 31.666666666666668]), { cols: agg.columns, row: agg.rows[0] });
+  const w = await executeSQL(engine, 'SELECT name, age FROM users WHERE age > 29 ORDER BY age DESC', opts);
+  ok('WHERE + ORDER BY', w.rows.length === 2 && w.rows[0][1] === 40, w.rows);
+  const funcs = await executeSQL(engine, "SELECT CONCAT(name, '!') AS c, UPPER(name) AS u, IFNULL(age, 0) AS f FROM users LIMIT 1", opts);
+  ok('scalar functions CONCAT/UPPER/IFNULL', funcs.rows[0][0] === 'A!' && funcs.rows[0][1] === 'A', funcs.rows);
+  const c1 = await executeSQL(engine, 'SELECT COUNT(1) AS n FROM users', opts);
+  ok('COUNT(1) literal', c1.rows[0][0] === 3, c1.rows);
+  ok('parseSQL TRUNCATE', parseSQL('TRUNCATE TABLE users').type === 'truncate');
+  ok('parseSQL START TRANSACTION', parseSQL('START TRANSACTION').type === 'begin');
+  ok('parseSQL VALUES DEFAULT', parseSQL(applyParams('INSERT INTO t (id, name) VALUES (DEFAULT, ?)', ['x'])).dataRows[0].id._default === true);
+  const srv = createMysqlServer({ port: 0, host: '127.0.0.1', dataDir: ':memory:', noAuth: true });
+  await new Promise(r => srv.listen(r));
+  const addr = srv.address;
+  ok('createMysqlServer listens on ephemeral port', addr && addr.port > 0, addr);
+  srv.close();
+  console.log(fail === 0 ? '\nALL SMOKE TESTS PASSED' : `\n${fail} FAILURES`);
+  process.exit(fail === 0 ? 0 : 1);
+})().catch(e => { console.error('FATAL', e.message); process.exit(1); });

package/wasm/browser.d.ts ADDED Viewed

@@ -0,0 +1,88 @@
+/**
+ * JSQL-NEO browser (WASM + IndexedDB) — ESM entry `jsql-neo/wasm/browser.mjs`.
+ */
+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 type Schema = Record<string, FieldDef>;
+export interface Row {
+  id: number | string;
+  fields?: Record<string, unknown>;
+  created_at?: string;
+  updated_at?: string;
+  [key: string]: unknown;
+}
+export interface FindOptions {
+  limit?: number;
+  offset?: number;
+}
+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 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 init(input?: Uint8Array | ArrayBuffer | Response | WebAssembly.Module | URL | string): Promise<JSQL | void>;