db-crud-api 0.3.19 → 0.3.25

package/lib/mysql.js

@@ -12,27 +12,55 @@ const pools = {};
 
 // Common
 function stringifyValue(fieldName, value, tSchema) {
-    if (value == undefined) { return 'null' }
-    if (typeof value !== 'string' || value.trimStart().charAt(0) !== '\`') {
-        if (tSchema.table.fields && tSchema.table.fields[fieldName] && tSchema.table.fields[fieldName].type) {
-            if (tSchema.table.fields[fieldName].type == 'datetime') {
-                if (typeof value == 'datetime' || typeof value == 'object') return `\'${value.toISOString().slice(0, 19).replace('T', ' ')}\'`;
-                if (typeof value == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') return `\'${value}\'`;
-                return value;
-            }
-            if (tSchema.table.fields[fieldName].type == 'boolean' && typeof value == 'boolean') return `\'${value}\'`;
-            if (tSchema.table.fields[fieldName].type == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') return `\'${value}\'`;
-            if (tSchema.table.fields[fieldName].type == 'uuid' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') return `\'${value}\'`;
+
+    // null or undefined
+    if (value == undefined)  
+        return 'null';
+
+    // detect field type
+    let _fieldType = undefined;
+    if (tSchema.table.fields && tSchema.table.fields[fieldName] && tSchema.table.fields[fieldName].type) {
+        _fieldType = tSchema.table.fields[fieldName].type;
+    }
+
+    // if datetime
+    if (_fieldType == 'datetime') {
+        // my-sql not accepts 'Z' at end of ISO string
+        if (value instanceof Date) 
+            return `\'${value.toISOString().slice(0, -1)}\'`;
+        if (typeof value == 'string') {
+            const valueDate = new Date(Date.parse(value));
+            return `\'${valueDate.toISOString().slice(0, -1)}\'`;
         }
-        else {
-            // if (typeof value == 'datetime') return `\'${value.toISOString().slice(0, 19).replace('T', ' ')}\'`;
-            if (typeof value == 'boolean') return `\'${value}\'`;
-            if (typeof value == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') return `\'${value}\'`;
+        return value;
+    }
+                
+    // if boolean
+    if (_fieldType == 'boolean' && typeof value == 'boolean') 
+        return `\'${value}\'`;
+
+    // if string or uuid
+    if (_fieldType == 'string' || _fieldType == 'uuid') {
+        if (value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') {
+            return `\'${value}\'`;
         }
     }
+
+    // field not in schema
+    if (_fieldType == undefined) {
+        if (value instanceof Date) 
+            return `\'${value.toISOString().slice(0, -1)}\'`;
+        if (typeof value == 'boolean') 
+            return `\'${value}\'`;
+        if (typeof value == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') 
+            return `\'${value}\'`;
+    }
+
     return value;
 }
 
+
+
 // Create config object for pool
 export function prepareConnection(tSchema) {
     return {
@@ -55,7 +83,7 @@ export async function closeConnection(connection) {
     let pool = pools[connection.id];
     if (pool) {
         pool.releaseConnection();
-        connection.end();
+        await connection.end();
         pools[connection.id] = undefined;  // remove pool from pools
     }
 }
@@ -66,7 +94,7 @@ export async function closeAllConnections() {
         if (!pools.hasOwnProperty(poolId)) continue;
         let pool = pools[poolId];
         if (pool) {
-            pool.end();
+            await pool.end();
             pool = undefined;  // remove pool from pools
         }
     }
@@ -97,15 +125,26 @@ export async function query(connection, dbOpes) {
 
     // Prepare sql statement
     let sqlString = '';
+    let appLog = true;
     // if exists, input params will be added to request
-    if (Array.isArray(dbOpes)) dbOpes.forEach((dbOpe, index) => { sqlString += ToSql(dbOpe, pool); });
-    else sqlString += ToSql(dbOpes, pool);
+    if (Array.isArray(dbOpes)) {
+        dbOpes.forEach((dbOpe, index) => { 
+            sqlString += ToSql(dbOpe, pool);
+            if (dbOpe?.hasOwnProperty('appLog') && dbOpe.appLog === false) appLog = false; 
+        });
+    }
+    else {
+        sqlString += ToSql(dbOpes, pool);
+        if (dbOpes?.hasOwnProperty('appLog') && dbOpes.appLog === false) appLog = false; 
+    }
 
     sqlString = normalizeSpecialName(sqlString);
 
     // Log
-    log(JSON.stringify(dbOpes), 60);
-    log(sqlString, 50);
+    if (appLog) {
+        log(JSON.stringify(dbOpes), 60);
+        log(sqlString, 50);
+    }
 
     // Run query
     let sqlresult = undefined;
@@ -118,7 +157,9 @@ export async function query(connection, dbOpes) {
     finally { if (sqlconn) sqlconn.release(); }
 
     // Log
-    log(`Query result: ${(sqlresult && sqlresult.length > 0) ? sqlresult[0].length : 0} rows.`, 50);
+    if (appLog) {
+        log(`Query result: ${(sqlresult && sqlresult.length > 0) ? sqlresult[0].length : 0} rows.`, 50);
+    }
 
     // normalize return object
     if (sqlresult == undefined) return;
@@ -128,9 +169,36 @@ export async function query(connection, dbOpes) {
     return sqlresult[0];
 }
 
-// Normalize SpecialName
-function normalizeSpecialName(name) {
-    return name.replaceAll('[', '\`').replaceAll(']', '\`');
+// Normalize special name to replace square brackets with backticks, considering quoted strings
+function normalizeSpecialName(sql) {
+    let result = "";
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+
+    for (let i = 0; i < sql.length; i++) {
+        const char = sql[i];
+
+        // Gestione delle virgolette singole '
+        if (char === "'" && !inDoubleQuote) {
+            inSingleQuote = !inSingleQuote;
+        } 
+        // Gestione delle virgolette doppie "
+        else if (char === '"' && !inSingleQuote) {
+            inDoubleQuote = !inDoubleQuote;
+        }
+
+        // Se non siamo all'interno di una stringa, sostituiamo le quadre
+        if (!inSingleQuote && !inDoubleQuote) {
+            if (char === '[' || char === ']') {
+                result += '`';
+                continue;
+            }
+        }
+
+        result += char;
+    }
+
+    return result;
 }
 
 // Compose fully qualified table name
@@ -138,7 +206,6 @@ function fullyQualifiedTableName(tSchema) {
     return (tSchema.database.realName + '.' + tSchema.table.realName);
 }
 
-
 function containLIMIT(s) {
     const _return = s?.match(_match_LIMIT_n);
     if (_return) return _return[0];

package/lib/mysql.js.bak

@@ -0,0 +1,404 @@
+'use strict';
+
+import sql from 'mysql2/promise';
+import log from './log.js'
+
+// Regex
+const _match_LIMIT_n = /\bLIMIT\b +\d+/ig
+const _match_TOP_n = /\bTOP\b +\d+/ig
+const _match_TOP = /\bTOP\b/ig
+
+const pools = {};
+
+// Common
+function stringifyValue(fieldName, value, tSchema) {
+
+    // null or undefined
+    if (value == undefined)  
+        return 'null';
+
+    // detect field type
+    let _fieldType = undefined;
+    if (tSchema.table.fields && tSchema.table.fields[fieldName] && tSchema.table.fields[fieldName].type) {
+        _fieldType = tSchema.table.fields[fieldName].type;
+    }
+
+    // if datetime
+    if (_fieldType == 'datetime') {
+        // my-sql not accepts 'Z' at end of ISO string
+        if (value instanceof Date) 
+            return `\'${value.toISOString().slice(0, -1)}\'`;
+        if (typeof value == 'string') {
+            const valueDate = new Date(Date.parse(value));
+            return `\'${valueDate.toISOString().slice(0, -1)}\'`;
+        }
+        return value;
+    }
+                
+    // if boolean
+    if (_fieldType == 'boolean' && typeof value == 'boolean') 
+        return `\'${value}\'`;
+
+    // if string or uuid
+    if (_fieldType == 'string' || _fieldType == 'uuid') {
+        if (value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') {
+            return `\'${value}\'`;
+        }
+    }
+
+    // field not in schema
+    if (_fieldType == undefined) {
+        if (value instanceof Date) 
+            return `\'${value.toISOString().slice(0, -1)}\'`;
+        if (typeof value == 'boolean') 
+            return `\'${value}\'`;
+        if (typeof value == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') 
+            return `\'${value}\'`;
+    }
+
+    return value;
+}
+
+
+
+// Create config object for pool
+export function prepareConnection(tSchema) {
+    return {
+        id: `${tSchema.server.realName}-${tSchema.database.realName}-${tSchema.server.user}`,
+        host: ((tSchema.server.instance && tSchema.server.instance != 'DEFAULT') ? (tSchema.server.realName + '\\' + tSchema.server.instance) : tSchema.server.realName) ?? 'localhost',
+        port: tSchema.server.port,
+        user: tSchema.server.user,
+        password: tSchema.server.password,
+        database: tSchema.database.realName,
+        ssl: {
+            rejectUnauthorized: false
+        },
+        multipleStatements: true,
+        connectionLimit: tSchema.server.connectionLimit
+    };
+};
+
+// Close connection
+export async function closeConnection(connection) {
+    let pool = pools[connection.id];
+    if (pool) {
+        pool.releaseConnection();
+        connection.end();
+        pools[connection.id] = undefined;  // remove pool from pools
+    }
+}
+
+// Close all connections
+export async function closeAllConnections() {
+    for (let poolId in pools) {
+        if (!pools.hasOwnProperty(poolId)) continue;
+        let pool = pools[poolId];
+        if (pool) {
+            pool.end();
+            pool = undefined;  // remove pool from pools
+        }
+    }
+}
+
+// Test connection
+export async function testConnection(connection) {
+  try {
+    const _connection = await sql.createConnection(connection);
+    await _connection.end();
+    return true;
+  } 
+  catch (error) 
+  {
+    throw (error);
+  }
+}
+
+// Query
+export async function query(connection, dbOpes) {
+
+    // Prepare pool
+    let pool = pools[connection.id];  // Try to get an existing pool
+    if (!pool) {
+        pool = new sql.createPool(connection);  // Create new pool
+        pools[connection.id] = pool;  // add new pool to pools
+    }
+
+    // Prepare sql statement
+    let sqlString = '';
+    let appLog = true;
+    // if exists, input params will be added to request
+    if (Array.isArray(dbOpes)) {
+        dbOpes.forEach((dbOpe, index) => { 
+            sqlString += ToSql(dbOpe, pool);
+            if (dbOpe?.hasOwnProperty('appLog') && dbOpe.appLog === false) appLog = false; 
+        });
+    }
+    else {
+        sqlString += ToSql(dbOpes, pool);
+        if (dbOpes?.hasOwnProperty('appLog') && dbOpes.appLog === false) appLog = false; 
+    }
+
+    sqlString = normalizeSpecialName(sqlString);
+
+    // Log
+    if (appLog) {
+        log(JSON.stringify(dbOpes), 60);
+        log(sqlString, 50);
+    }
+
+    // Run query
+    let sqlresult = undefined;
+    let sqlconn = undefined;
+    try {
+        sqlconn = await pool.getConnection();
+        sqlresult = await sqlconn.query(sqlString);
+    }
+    catch (err) { throw (err); } // using original error
+    finally { if (sqlconn) sqlconn.release(); }
+
+    // Log
+    if (appLog) {
+        log(`Query result: ${(sqlresult && sqlresult.length > 0) ? sqlresult[0].length : 0} rows.`, 50);
+    }
+
+    // normalize return object
+    if (sqlresult == undefined) return;
+    if (sqlresult.length === 0) return;
+    if (sqlresult[0].length === 0) return;
+
+    return sqlresult[0];
+}
+
+// Normalize special name to replace square brackets with backticks, considering quoted strings
+function normalizeSpecialName(sql) {
+    let result = "";
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+
+    for (let i = 0; i < sql.length; i++) {
+        const char = sql[i];
+
+        // Gestione delle virgolette singole '
+        if (char === "'" && !inDoubleQuote) {
+            inSingleQuote = !inSingleQuote;
+        } 
+        // Gestione delle virgolette doppie "
+        else if (char === '"' && !inSingleQuote) {
+            inDoubleQuote = !inDoubleQuote;
+        }
+
+        // Se non siamo all'interno di una stringa, sostituiamo le quadre
+        if (!inSingleQuote && !inDoubleQuote) {
+            if (char === '[' || char === ']') {
+                result += '`';
+                continue;
+            }
+        }
+
+        result += char;
+    }
+
+    return result;
+}
+
+// Compose fully qualified table name
+function fullyQualifiedTableName(tSchema) {
+    return (tSchema.database.realName + '.' + tSchema.table.realName);
+}
+
+function containLIMIT(s) {
+    const _return = s?.match(_match_LIMIT_n);
+    if (_return) return _return[0];
+    else return undefined;
+};
+
+function containTOP(s) {
+    const _return = s?.match(_match_TOP_n);
+    if (_return) return _return[0];
+    else return undefined;
+};
+
+function replaceTOPToLIMIT(s) {
+    const _replace = containTOP(s);
+    if (_replace) { return s.replace(_match_TOP_n, _replace.replace(_match_TOP, 'LIMIT')); }
+    else return s;
+}
+
+// Parse oprations object to sql string
+function ToSql(dbOpe, sqlRequest) {
+    if (dbOpe.get) return getToSql(dbOpe, sqlRequest);
+    if (dbOpe.patch) return patchToSql(dbOpe, sqlRequest);
+    if (dbOpe.put) return putToSql(dbOpe, sqlRequest);
+    if (dbOpe.delete) return deleteToSql(dbOpe, sqlRequest);
+    if (dbOpe.execute) return executeToSql(dbOpe, sqlRequest);
+    if (dbOpe.begin) return beginToSql(dbOpe, sqlRequest);
+    if (dbOpe.commit) return commitToSql(dbOpe, sqlRequest);
+    if (dbOpe.passthrough) return passthroughToSql(dbOpe, sqlRequest);
+}
+
+// Parse operation object to sql string without any trasformation.
+function passthroughToSql(dbOpe, sqlRequest) {
+
+    let result = "";
+
+    if (dbOpe.passthrough.command) {
+        result += dbOpe.passthrough.command;
+    }
+    else { throw new Error('command is missing.'); }
+
+    if (dbOpe.passthrough.params) addParams(dbOpe.passthrough.params, sqlRequest);
+
+    return result;
+}
+
+// Parse get operation object to sql string
+function getToSql(dbOpe, sqlRequest) {
+    let _first = true;
+
+    let result = 'select'
+
+    // omit 'limit' or 'top'
+    if (dbOpe.get.options && dbOpe.get.options.length > 0) {
+        if (Array.isArray(dbOpe.get.options)) {
+            for (const s of dbOpe.get.options) { if (!containLIMIT(s) && !containTOP(s)) result += ' ' + s; }
+        }
+        else if (!containLIMIT(dbOpe.get.options) && !containTOP(dbOpe.get.options)) result += ' ' + dbOpe.get.options;
+    }
+
+    if (dbOpe.get.fields && dbOpe.get.fields.length > 0) {
+        if (Array.isArray(dbOpe.get.fields)) result += ' ' + dbOpe.get.fields.join(',')
+        else result += ' ' + dbOpe.get.fields;
+    }
+    else { throw new Error('fields is missing.'); }
+
+    result += ' from ' + fullyQualifiedTableName(dbOpe.get.schema);
+
+    if (dbOpe.get.filters && dbOpe.get.filters.length > 0) {
+        if (Array.isArray(dbOpe.get.filters)) result += ' where ' + dbOpe.get.filters.join(' ');
+        else result += ' where ' + dbOpe.get.filters;
+    }
+
+    if (dbOpe.get.groups && dbOpe.get.groups.length > 0) {
+        if (Array.isArray(dbOpe.get.groups)) result += ' group by ' + dbOpe.get.groups.join(', ');
+        else result += ' group by ' + dbOpe.get.groups;
+    }
+
+    if (dbOpe.get.groupsFilters && dbOpe.get.groupsFilters.length > 0) {
+        if (Array.isArray(dbOpe.get.groupsFilters)) result += ' having ' + dbOpe.get.groupsFilters.join(' ');
+        else result += ' having ' + dbOpe.get.groupsFilters;
+    }
+
+    if (dbOpe.get.orderBy && dbOpe.get.orderBy.length > 0) {
+        if (Array.isArray(dbOpe.get.orderBy)) result += ' order by ' + dbOpe.get.orderBy.join(', ');
+        else result += ' order by ' + dbOpe.get.orderBy;
+    }
+
+    // search if 'limit' or 'top'
+    if (dbOpe.get.options && dbOpe.get.options.length > 0) {
+        if (Array.isArray(dbOpe.get.options)) {
+            for (const s of dbOpe.get.options) { if (containLIMIT(s) || containTOP(s)) result += ' ' + replaceTOPToLIMIT(s); }
+        }
+        else if (containLIMIT(dbOpe.get.options) || containTOP(dbOpe.get.options)) result += ' ' + replaceTOPToLIMIT(dbOpe.get.options);
+    }
+
+    if (dbOpe.get.params) addParams(dbOpe.get.params, sqlRequest);
+
+    result += ';'
+
+    return result;
+}
+
+// Parse patch operation object to sql string
+function patchToSql(dbOpe, sqlRequest) {
+    let result = 'update ' + fullyQualifiedTableName(dbOpe.patch.schema);
+
+    if (dbOpe.patch.sets) { result += ' set ' + Object.entries(dbOpe.patch.sets).map(e => { return e[0] + '=' + stringifyValue(e[0], e[1], dbOpe.patch.schema) }).join(', '); }
+    else { throw new Error('sets is missing.'); }
+
+    if (dbOpe.patch.filters && dbOpe.patch.filters.length > 0) {
+        if (Array.isArray(dbOpe.patch.filters)) result += ' where ' + dbOpe.patch.filters.join(' ');
+        else result += ' where ' + dbOpe.patch.filters;
+    }
+
+    if (dbOpe.patch.params) addParams(dbOpe.patch.params, sqlRequest);
+
+    result += ';'
+
+    return result;
+}
+
+// Parse put (add) operation object to sql string
+function putToSql(dbOpe, sqlRequest) {
+    let result = 'insert into ' + fullyQualifiedTableName(dbOpe.put.schema);
+
+    if ((dbOpe.put.sets) && (Object.keys(dbOpe.put.sets).length > 0)) {
+        let result_f = ' ('; let result_v = ' values (';
+        let _first = true;
+        for (const [key, value] of Object.entries(dbOpe.put.sets)) {
+            if (!_first) { result_f += ', '; result_v += ', '; } else { _first = false }
+            if (key || value) { result_f += key; result_v += stringifyValue(key, value, dbOpe.put.schema); }
+        }
+        result_f += ')'; result_v += ')';
+        result += result_f + result_v;
+    }
+    else { throw new Error('sets is missing.'); }
+
+    if (dbOpe.put.params) addParams(dbOpe.put.params, sqlRequest);
+
+    result += ';'
+
+    return result;
+}
+
+// Parse delete operation object to sql string
+function deleteToSql(dbOpe, sqlRequest) {
+    let result = 'delete from ' + fullyQualifiedTableName(dbOpe.delete.schema);
+
+    if (dbOpe.delete.filters && dbOpe.delete.filters.length > 0) {
+        if (Array.isArray(dbOpe.delete.filters)) result += ' where ' + dbOpe.delete.filters.join(' ');
+        else result += ' where ' + dbOpe.delete.filters;
+    }
+
+    if (dbOpe.delete.params) addParams(dbOpe.delete.params, sqlRequest);
+
+    result += ';'
+
+    return result;
+}
+
+// Parse execute operation object to sql string
+function executeToSql(dbOpe, sqlRequest) {
+    let result = "CALL ";
+
+    if (dbOpe.execute.schema.procedure) {
+        result += dbOpe.execute.schema.procedure.command;
+        if (dbOpe.execute.arguments) { result += ('(' + dbOpe.execute.arguments) + ')'; }
+    }
+    else { throw new Error('missing procedure/function name.'); }
+
+    if (dbOpe.execute.params) addParams(dbOpe.execute.params, sqlRequest);
+
+    result += ';'
+
+    return result;
+}
+
+// Parse begin operation object to sql string
+function beginToSql(dbOpe, sqlRequest) {
+    return "START TRANSACTION; ";
+}
+
+// Parse commit operation object to sql string
+function commitToSql(dbOpe, sqlRequest) {
+    return " COMMIT;";
+}
+
+// Add input parameters to pool.request
+function addParams(params, sqlRequest) {
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            sqlRequest.input(key, value)
+        }
+    }
+    return;
+}

package/lib/schema.js

@@ -1,14 +1,14 @@
-export default {
-    servers: {
-    },
-    config: {
-        log: {
-            level: 0,
-            callback: undefined,
-            maxAsyncInstance: 50
-        },
-        session: {
-            tablePath: 'sessions'        
-        }
-    }
+export default {
+    servers: {
+    },
+    config: {
+        log: {
+            level: 0,
+            callback: undefined,
+            maxAsyncInstance: 50
+        },
+        session: {
+            tablePath: 'sessions'        
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "db-crud-api",
-  "version": "0.3.19",
+  "version": "0.3.25",
   "type": "module",
   "description": "CRUD api for database tables",
   "main": "index.js",