jsql-neo 4.3.0 → 4.4.0

package/lib/migrate.js

@@ -0,0 +1,242 @@
+/*
+ * Migration tools: mysqldump import, JSON import/export, CSV import/export.
+ *
+ * Works against any engine exposing:
+ *   hasTable(name) / getTableSchema(name) / find(name, {}, {limit, offset})
+ *   createTable(name, schema) / insert(name, rows) / executeSQL(sql, ...)
+ * (Database instances and the jsql-neo MySQL server engine both qualify.)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { splitStatements, executeSQL } = require('./sql');
+
+function normalizeSchema(schema) {
+  const out = {};
+  for (const [name, def] of Object.entries(schema || {})) {
+    const d = typeof def === 'string' ? { type: def } : { ...def };
+    if (!d.type) d.type = typeof d === 'object' ? 'any' : 'string';
+    if (d.type === 'int' || d.type === 'bigint' || d.type === 'smallint' || d.type === 'tinyint') d.type = 'integer';
+    if (d.type === 'varchar' || d.type === 'text' || d.type === 'char') d.type = 'string';
+    if (d.type === 'double' || d.type === 'real' || d.type === 'decimal' || d.type === 'numeric') d.type = 'float';
+    if (d.type === 'bool') d.type = 'boolean';
+    delete d.length;
+    if (d.maxLength) { d.length = d.maxLength; delete d.maxLength; }
+    out[name] = d;
+  }
+  return out;
+}
+
+function serializeValue(v) {
+  if (v === null || v === undefined) return '';
+  if (v instanceof Date) return v.toISOString();
+  if (typeof v === 'object') return JSON.stringify(v);
+  return String(v);
+}
+
+function parseValue(str, type) {
+  if (str === '' || str === null || str === undefined) return null;
+  const t = String(type || 'string').toLowerCase();
+  if (t === 'integer') return Number.isFinite(Number(str)) ? Math.trunc(Number(str)) : str;
+  if (t === 'float' || t === 'number') return Number.isFinite(Number(str)) ? Number(str) : str;
+  if (t === 'boolean') {
+    const s = str.toLowerCase();
+    if (['1', 'true', 'yes', 'y'].includes(s)) return true;
+    if (['0', 'false', 'no', 'n'].includes(s)) return false;
+    return str;
+  }
+  if (t === 'object' || t === 'array') {
+    try { return JSON.parse(str); } catch (e) { return str; }
+  }
+  return str;
+}
+
+function parseCSV(text) {
+  const rows = [];
+  let row = [];
+  let field = '';
+  let inQuotes = false;
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    const c = text[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (text[i + 1] === '"') { field += '"'; i += 2; continue; }
+        inQuotes = false;
+        i++;
+        continue;
+      }
+      field += c;
+      i++;
+      continue;
+    }
+    if (c === '"' && field === '') { inQuotes = true; i++; continue; }
+    if (c === ',') { row.push(field); field = ''; i++; continue; }
+    if (c === '\n' || c === '\r') {
+      if (c === '\r' && text[i + 1] === '\n') i++;
+      row.push(field);
+      field = '';
+      if (row.length > 1 || row[0] !== '') rows.push(row);
+      row = [];
+      i++;
+      continue;
+    }
+    field += c;
+    i++;
+  }
+  if (field !== '' || row.length > 0) {
+    row.push(field);
+    if (row.length > 1 || row[0] !== '') rows.push(row);
+  }
+  return rows;
+}
+
+function toCSV(rows, columns) {
+  const escape = (v) => {
+    const s = serializeValue(v);
+    return /[",\n\r]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s;
+  };
+  const lines = [columns.map(escape).join(',')];
+  for (const r of rows) {
+    lines.push(columns.map(c => escape(r[c])).join(','));
+  }
+  return lines.join('\n') + '\n';
+}
+
+/* ---------- JSON ---------- */
+
+async function exportTableToJSON(engine, table) {
+  const schema = await engine.getTableSchema(table);
+  if (!schema) throw new Error(`Table '${table}' does not exist`);
+  const rows = await engine.find(table, {}, { limit: 1e9, offset: 0 });
+  return { table, schema, rows };
+}
+
+async function exportAllToJSON(engine, tables) {
+  const list = tables || await engine.getTables();
+  const out = {};
+  for (const t of list) out[t] = await exportTableToJSON(engine, t);
+  return out;
+}
+
+async function importFromJSON(engine, data) {
+  const tables = typeof data === 'string' ? JSON.parse(data) : data;
+  const created = [];
+  let inserted = 0;
+  for (const [name, t] of Object.entries(tables)) {
+    if (!t || !t.schema) continue;
+    if (engine.hasTable(name)) await engine.dropTable(name);
+    await engine.createTable(name, normalizeSchema(t.schema));
+    created.push(name);
+    if (Array.isArray(t.rows) && t.rows.length > 0) {
+      const ids = await engine.insert(name, t.rows.map(r => ({ ...r.fields, id: r.id })));
+      inserted += Array.isArray(ids) ? ids.length : t.rows.length;
+    }
+  }
+  return { created, inserted };
+}
+
+/* ---------- CSV ---------- */
+
+async function exportTableToCSV(engine, table) {
+  const schema = await engine.getTableSchema(table);
+  if (!schema) throw new Error(`Table '${table}' does not exist`);
+  const columns = Object.keys(schema);
+  const rows = await engine.find(table, {}, { limit: 1e9, offset: 0 });
+  return toCSV(rows, columns);
+}
+
+async function importFromCSV(engine, table, csv, opts = {}) {
+  const schema = opts.schema || await engine.getTableSchema(table);
+  const rows = parseCSV(csv);
+  if (rows.length === 0) return { inserted: 0 };
+  let columns;
+  let start = 0;
+  if (opts.header !== false) {
+    columns = rows[0];
+    start = 1;
+  } else if (schema) {
+    columns = Object.keys(schema);
+  } else {
+    columns = rows[0].map((_, i) => 'col' + (i + 1));
+  }
+  if (!engine.hasTable(table)) {
+    if (!schema) {
+      throw new Error(`Table '${table}' does not exist; provide opts.schema to create it`);
+    }
+    await engine.createTable(table, normalizeSchema(schema));
+  }
+  const dataRows = [];
+  for (let i = start; i < rows.length; i++) {
+    const row = {};
+    for (let j = 0; j < columns.length; j++) {
+      const type = schema && schema[columns[j]] ? schema[columns[j]].type : 'string';
+      row[columns[j]] = parseValue(rows[i][j], type);
+    }
+    if (row.id === null || row.id === undefined || row.id === '') delete row.id;
+    dataRows.push(row);
+  }
+  const ids = dataRows.length > 0 ? await engine.insert(table, dataRows) : [];
+  return { inserted: dataRows.length, ids };
+}
+
+/* ---------- mysqldump ---------- */
+
+async function importDump(engine, sqlText, opts = {}) {
+  const statements = splitStatements(sqlText);
+  const created = [];
+  let inserted = 0;
+  const errors = [];
+  for (const raw of statements) {
+    const stmt = raw.trim();
+    if (!stmt) continue;
+    if (stmt.startsWith('--') || stmt.startsWith('#')) continue;
+    const upper = stmt.toUpperCase();
+    if (upper.startsWith('LOCK ') || upper.startsWith('UNLOCK ')) continue;
+    if (upper.startsWith('/*!')) continue;
+    if (upper.startsWith('SET ') && opts.skipSet !== false) continue;
+    try {
+      const r = await executeSQL(engine, stmt, { safety: false });
+      if (r && r.type === 'createTable') created.push(r.table);
+      if (r && r.type === 'insert') inserted += (r.ids || []).length || r.affectedRows || 0;
+    } catch (e) {
+      if (opts.strict) throw e;
+      errors.push({ sql: stmt.slice(0, 120), error: e.message });
+    }
+  }
+  return { created, inserted, errors };
+}
+
+async function importDumpFile(engine, filePath, opts = {}) {
+  const text = fs.readFileSync(filePath, 'utf8');
+  return importDump(engine, text, opts);
+}
+
+async function exportToFile(engine, table, filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  let content;
+  if (ext === '.json') {
+    content = JSON.stringify(await exportTableToJSON(engine, table), null, 2);
+  } else if (ext === '.csv') {
+    content = await exportTableToCSV(engine, table);
+  } else {
+    throw new Error('Unsupported export format (use .json or .csv): ' + filePath);
+  }
+  fs.writeFileSync(filePath, content);
+  return content.length;
+}
+
+module.exports = {
+  normalizeSchema,
+  parseCSV,
+  toCSV,
+  exportTableToJSON,
+  exportAllToJSON,
+  importFromJSON,
+  exportTableToCSV,
+  importFromCSV,
+  importDump,
+  importDumpFile,
+  exportToFile,
+};

package/lib/mysql_server.js

@@ -31,6 +31,7 @@ const MYSQL_TYPE_TINY = 1, MYSQL_TYPE_LONG = 3, MYSQL_TYPE_LONGLONG = 8,
   MYSQL_TYPE_JSON = 245, MYSQL_TYPE_NULL = 6;
 
 function encodeLenenc(value) {
+  if (typeof value === 'bigint') value = Number(value);
   if (value === null) return Buffer.from([0xfb]);
   if (value < 0xfb) return Buffer.from([value]);
   if (value <= 0xffff) {
@@ -135,7 +136,38 @@ function toMysqlErrno(e) {
   if (e && typeof e.code === 'number') return e.code;
   const m = e && e.message ? String(e.message).match(/^(ER_[A-Z_]+)/) : null;
   if (m) {
-    const known = { ER_DUP_ENTRY: 1062, ER_NO_SUCH_TABLE: 1146, ER_TABLE_EXISTS: 1050, ER_PARSE_ERROR: 1064 };
+    const known = {
+      ER_DUP_ENTRY: 1062,
+      ER_NO_SUCH_TABLE: 1146,
+      ER_TABLE_EXISTS: 1050,
+      ER_TABLE_EXISTS_ERROR: 1050,
+      ER_PARSE_ERROR: 1064,
+      ER_BAD_FIELD_ERROR: 1054,
+      ER_BAD_NULL_ERROR: 1048,
+      ER_ACCESS_DENIED_ERROR: 1045,
+      ER_DBACCESS_DENIED_ERROR: 1044,
+      ER_BAD_DB_ERROR: 1049,
+      ER_WRONG_DB_NAME: 1102,
+      ER_WRONG_TABLE_NAME: 1103,
+      ER_WRONG_COLUMN_NAME: 1166,
+      ER_DATA_TOO_LONG: 1406,
+      ER_OUT_OF_RANGE: 1264,
+      ER_CHECK_CONSTRAINT: 3819,
+      ER_NO_DEFAULT_FOR_FIELD: 1364,
+      ER_CANT_DROP_FIELD_OR_KEY: 1091,
+      ER_CANT_DROP_DATABASE: 1008,
+      ER_EMPTY_QUERY: 1065,
+      ER_UNKNOWN_TABLE: 1109,
+      ER_NON_UNIQ_ERROR: 1052,
+      ER_WRONG_FIELD_WITH_GROUP: 1055,
+      ER_WRONG_VALUE_COUNT_ON_ROW: 1136,
+      ER_MISSING_TABLE: 1052,
+      ER_SP_DOES_NOT_EXIST: 1305,
+      ER_NOT_SUPPORTED_YET: 1235,
+      ER_LOCK_DEADLOCK: 1213,
+      ER_LOCK_WAIT_TIMEOUT: 1205,
+      ER_UNKNOWN_ERROR: 1105,
+    };
     if (known[m[1]]) return known[m[1]];
   }
   return 1105;
@@ -273,11 +305,13 @@ function binaryResultSetPacket(result, tableSchema, baseSeq) {
     if (type === MYSQL_TYPE_LONG || type === MYSQL_TYPE_LONGLONG || type === MYSQL_TYPE_DOUBLE) {
       const num = Number(v);
       if (type === MYSQL_TYPE_DOUBLE) {
+        if (!Number.isFinite(num)) return encodeLenencString(String(v));
         const b = Buffer.alloc(8); b.writeDoubleLE(num, 0); return b;
       }
       if (Number.isInteger(num) && num <= 2147483647 && num >= -2147483648) {
         const b = Buffer.alloc(4); b.writeInt32LE(num, 0); return b;
       }
+      if (!Number.isFinite(num)) return encodeLenencString(String(v));
       const b = Buffer.alloc(8); b.writeBigInt64LE(BigInt(Math.trunc(num)), 0); return b;
     }
     if (type === MYSQL_TYPE_TINY) {
@@ -339,6 +373,14 @@ class MysqlConnection {
     this.multiStatements = false;
     this._stmts = new Map();
     this._stmtSeq = 0;
+    this.session = {
+      lastInsertId: 0,
+      rowCount: 0,
+      foundRows: 0,
+      connectionId: server._connectionCounter,
+      currentDb: null,
+      sysvars: {},
+    };
     if (server.handshakeTimeout > 0) {
       this._authTimer = setTimeout(() => {
         if (!this.authenticated) {
@@ -804,10 +846,12 @@ class MysqlConnection {
             allowComments: this.server.allowComments,
             safety: this.server.safety,
             maxStatements: 1,
+            session: this.session,
           });
           if (r.type === 'select' || r.type === 'showTables' || r.type === 'showDatabases' || r.type === 'describe'
             || r.type === 'showColumns' || r.type === 'showIndex' || r.type === 'showCreateTable'
             || r.type === 'showVariables' || r.type === 'showStatus' || r.type === 'showGrants' || r.type === 'showWarnings') {
+            this.session.foundRows = (r.raw && r.raw.length !== undefined) ? r.raw.length : (r.rows ? r.rows.length : 0);
             let schema = null;
             if (r.table) {
               schema = engine.getTableSchema
@@ -820,6 +864,12 @@ class MysqlConnection {
             this.sequence = sequence;
             this.socket.write(Buffer.concat(packets));
           } else {
+            if (r.type === 'insert') {
+              this.session.lastInsertId = r.insertId;
+              this.session.rowCount = r.affectedRows;
+            } else if (r.type === 'update' || r.type === 'delete' || r.type === 'truncate') {
+              this.session.rowCount = r.affectedRows;
+            }
             this._send(okPacket(r.affectedRows || 0, r.insertId || 0));
           }
         }