jsql-neo 4.5.1 → 5.0.0

package/lib/mysql_server.js

@@ -909,7 +909,7 @@ class MysqlServer {
     this._engine = null;
     this._ownEngine = false;
     this._databases = new Map();
-    this._dbDir = options.dataDir ? path.resolve(options.dataDir) : null;
+    this._dbDir = options.dataDir && options.dataDir !== ':memory:' ? path.resolve(options.dataDir) : null;
     this._defaultDbName = options.defaultDatabase || 'default';
     this._connectionCounter = 0;
     this._sockets = new Set();

package/lib/native_client.js

@@ -7,6 +7,69 @@ const STR_TAG = 3;
 const BOOL_TAG = 4;
 const INT32_TAG = 5;
 
+function safeParse(str, fallback) {
+  if (typeof str !== 'string') return fallback;
+  try { return JSON.parse(str); } catch (e) { return fallback; }
+}
+
+const NATIVE_TYPE_MAP = {
+  text: 'string',
+  varchar: 'string',
+  double: 'float',
+  number: 'float',
+  numeric: 'float',
+  decimal: 'float',
+  date: 'string',
+  timestamp: 'string',
+  datetime: 'string',
+  json: 'string',
+  array: 'string',
+  object: 'string',
+  bool: 'boolean',
+  bigint: 'string',
+  int: 'integer',
+};
+
+function mapNativeSchema(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() };
+    } else if (def && typeof def === 'object') {
+      const t = (def.type || 'string').toLowerCase();
+      mapped[field] = { ...def, type: NATIVE_TYPE_MAP[t] || t };
+    } else {
+      mapped[field] = { type: 'string' };
+    }
+  }
+  return mapped;
+}
+
+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;
+    }
+    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]);
+    } else {
+      out[field] = row[field];
+    }
+  }
+  return out;
+}
+
 function encodeBatch(rows) {
   if (rows.length === 0) return new Uint8Array(0);
   const fieldNames = Object.keys(rows[0]);
@@ -279,14 +342,23 @@ class JSQL {
   async start() {
     if (this._mode !== 'memory') {
       if (!this._path) throw new Error('hybrid/disk mode requires a directory path');
-      const r = JSON.parse(native.jsqlOpen(this._path, this._mode));
+      let r;
+      try {
+        r = safeParse(native.jsqlOpen(this._path, this._mode));
+      } catch (e) {
+        throw new Error('failed to open native storage: ' + e.message);
+      }
       if (r && r.ok === false) throw new Error(r.error || 'open storage failed');
       if (r && Array.isArray(r.tables)) {
         this._tableNames = new Set(r.tables);
         if (r.schemas) this._schemas = r.schemas;
       }
     } else {
-      JSON.parse(native.jsqlOpen('', 'memory'));
+      try {
+        JSON.parse(native.jsqlOpen('', 'memory'));
+      } catch (e) {
+        throw new Error('failed to open native memory storage: ' + e.message);
+      }
     }
     if (this._mode !== 'memory') {
       if (this._flushInterval > 0) {
@@ -319,8 +391,19 @@ class JSQL {
   }
 
   async _insertBatch(table, rows) {
+    const schema = this._schemas[table];
+    if (schema) {
+      rows = rows.map(row => {
+        const out = {};
+        for (const [k, v] of Object.entries(row)) {
+          if (v instanceof Date) out[k] = v.toISOString();
+          else out[k] = v;
+        }
+        return out;
+      });
+    }
     const bin = encodeBatch(rows);
-    const r = JSON.parse(native.jsqlInsertBuf(table, bin));
+    const r = safeParse(native.jsqlInsertBuf(table, bin));
     if (r && r.error) throw new Error(r.error);
     return r;
   }
@@ -340,13 +423,13 @@ class JSQL {
       var ids = remove[table];
       if (ids.size === 0) continue;
       var idsArr = Array.from(ids);
-      var r = JSON.parse(native.jsqlRemoveByIds(table, JSON.stringify(idsArr)));
+      var r = safeParse(native.jsqlRemoveByIds(table, JSON.stringify(idsArr)));
       this._emit('delete', { table, ids: idsArr, result: r });
     }
     for (var table in update) {
       var entries = update[table];
       if (entries.length === 0) continue;
-      var r = JSON.parse(native.jsqlUpdateByIds(table, JSON.stringify(entries)));
+      var r = safeParse(native.jsqlUpdateByIds(table, JSON.stringify(entries)));
       this._emit('update', { table, entries, result: r });
     }
     this._opBuffer = { remove: {}, update: {} };
@@ -410,7 +493,7 @@ class JSQL {
   async createTable(name, schema) {
     await this._flush();
     if (!this._runHooks('beforeCreateTable', [name, schema])) return null;
-    const r = JSON.parse(native.jsqlCreateTable(name, JSON.stringify(schema)));
+    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;
@@ -422,7 +505,7 @@ class JSQL {
   async dropTable(name) {
     await this._flush();
     if (!this._runHooks('beforeDropTable', [name])) return null;
-    const r = JSON.parse(native.jsqlDropTable(name));
+    const r = safeParse(native.jsqlDropTable(name));
     if (r && r.ok === false) throw new Error(r.error || 'drop table failed');
     this._tableNames.delete(name);
     delete this._schemas[name];
@@ -434,9 +517,11 @@ class JSQL {
   findById(table, id) {
     this._flushOpsNow();
     if (!this._runHooks('beforeFind', [table, { id }])) return null;
-    const raw = JSON.parse(native.jsqlFindById(table, Number(id)));
+    const raw = safeParse(native.jsqlFindById(table, Number(id)));
     if (raw && raw.error) throw new Error(raw.error);
     this._runHooks('afterFind', [table, { id }, raw]);
+    const schema = this._schemas[table];
+    if (schema && raw && typeof raw === 'object') return restoreRow(raw, schema);
     return raw;
   }
 
@@ -444,9 +529,11 @@ class JSQL {
     this._flushOpsNow();
     if (!this._runHooks('beforeFind', [table, { ids }])) return null;
     const resultStr = native.jsqlFindByIds(table, JSON.stringify(ids));
-    const r = JSON.parse(resultStr);
+    const r = safeParse(resultStr);
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { ids }, r]);
+    const schema = this._schemas[table];
+    if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
   }
 
@@ -459,9 +546,11 @@ class JSQL {
     if (!this._runHooks('beforeFind', [table, { filter, opts }])) return [];
     const filterStr = filter ? JSON.stringify(filter) : '';
     const { limit = 100, offset = 0 } = opts;
-    const r = JSON.parse(native.jsqlFind(table, filterStr, limit, offset));
+    const r = safeParse(native.jsqlFind(table, filterStr, limit, offset));
     if (r && r.error) throw new Error(r.error);
     this._runHooks('afterFind', [table, { filter, opts }, r]);
+    const schema = this._schemas[table];
+    if (schema && Array.isArray(r)) return r.map(row => restoreRow(row, schema));
     return r;
   }
 
@@ -529,19 +618,19 @@ class JSQL {
 
   async beginTx() {
     this._flushOpsNow();
-    const r = JSON.parse(native.jsqlBeginTx());
+    const r = safeParse(native.jsqlBeginTx());
     if (r && r.ok === false) throw new Error(r.error || 'begin transaction failed');
     return r.txId;
   }
 
   async commitTx(txId) {
-    const r = JSON.parse(native.jsqlCommitTx(String(txId)));
+    const r = safeParse(native.jsqlCommitTx(String(txId)));
     if (r && r.ok === false) throw new Error(r.error || 'commit transaction failed');
     return true;
   }
 
   async rollbackTx(txId) {
-    const r = JSON.parse(native.jsqlRollbackTx(String(txId)));
+    const r = safeParse(native.jsqlRollbackTx(String(txId)));
     if (r && r.ok === false) throw new Error(r.error || 'rollback transaction failed');
     return true;
   }