db-crud-wrapper 1.0.1

package/lib/mssql.js

@@ -0,0 +1,483 @@
+'use strict';
+
+import sql from 'mssql';
+import log from './log.js'
+
+// Regex
+const _match_LIMIT_n = /\bLIMIT\b +\d+/ig
+const _match_LIMIT = /\bLIMIT\b/ig
+
+const pools = {};
+
+// Common
+function isExpression(str) {
+  if (typeof str !== 'string') return false;
+  const trimmed = str.trim();
+  return (trimmed.startsWith('[') && trimmed.endsWith(']')) ||
+         (trimmed.startsWith('`') && trimmed.endsWith('`'));
+}
+
+function removeExpressionDelimiters(str) {
+  if (typeof str !== 'string') return str;
+  const trimmed = str.trim();
+  if ((trimmed.startsWith('[') && trimmed.endsWith(']')) ||
+      (trimmed.startsWith('`') && trimmed.endsWith('`'))) {
+    return trimmed.slice(1, -1);
+  }
+  return str;
+}
+
+function stringifyValue(fieldName, value, tSchema) {
+
+    // null or undefined
+    if (value == undefined) 
+        return 'null';
+
+    // if values is an expression than remove delimiters 
+    if (isExpression(value)) {
+        return removeExpressionDelimiters(value);
+    }
+
+    // detect field type from schema
+    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') {
+        if (value instanceof Date) return `\'${value.toISOString()}\'`;
+        if (typeof value == 'string') {
+            const valueDate = new Date(Date.parse(value));
+            return `\'${valueDate.toISOString()}\'`;
+        }
+        return value;
+    }
+                
+    // if boolean
+    if (_fieldType == 'boolean' && typeof value == 'boolean') 
+        return `\'${value}\'`;
+
+    // if string or uuid
+    if (_fieldType == 'string' || _fieldType == 'uuid') {
+        return `\'${String(value).replace(/'/g, "''")}\'`;
+    }
+
+    // field not in schema
+    if (_fieldType == undefined) {
+        if (value instanceof Date) 
+            return `\'${value.toISOString()}\'`;
+        if (typeof value == 'boolean') 
+            return `\'${value}\'`;
+        if (typeof value == 'string') 
+            return `\'${value.replace(/'/g, "''")}\'`;
+    }
+
+    return value;
+}
+
+// Create config object for pool
+export function prepareConnection(tSchema) {
+    return {
+        id: `${tSchema.server.realName}-${tSchema.database.realName}-${tSchema.server.user}`,
+        server: ((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,
+        options: {
+            appName: tSchema.server.options?.appName,
+            encrypt: tSchema.server.options?.encrypt ?? false, // true for azure
+            trustServerCertificate: tSchema.server.options?.trustServerCertificate ?? true // true for local dev / self-signed certs
+        },
+        pool: tSchema.server.pool,
+        database: tSchema.database.realName
+    };
+};
+
+// Close connection
+export async function closeConnection(connection) {
+    let pool = pools[connection.id];
+    if (pool) {
+        await pool.close();  // wait pool is closed
+        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) {
+            await pool.close();  // wait pool is closed
+            pool = undefined;  // remove pool from pools
+        }
+    }
+}
+
+// Test connection
+export async function testConnection(connection) {
+
+    let _connection;
+    try {
+        _connection = await sql.connect(connection);
+        return true;
+    }
+    catch (error) {
+        throw (error);
+    }
+    finally {
+        if (_connection) {
+            await _connection.close();
+        }
+    }
+
+}
+
+// Query
+export async function query(connection, dbOpes, rawResult = false) {
+
+    // Prepare pool
+    let pool = pools[connection.id];  // Try to get an existing pool
+    if (!pool) {
+        pool = new sql.ConnectionPool(connection);  // Create new pool
+        try {
+            await pool.connect();  // wait that connection are made
+        } catch (err) { 
+            throw (err); // using original error
+        } 
+        pools[connection.id] = pool;  // add new pool to pools
+    }
+
+    // Prepare sql statement
+    let sqlString = '';
+    let sqlRequest = pool.request();
+    let appLog = true;
+    // if exists, input params will be added to request
+    if (Array.isArray(dbOpes)) {
+        dbOpes.forEach((dbOpe, index) => { 
+            sqlString += ToSql(dbOpe, sqlRequest);
+            if (dbOpe.hasOwnProperty('appLog') && dbOpe.appLog === false) appLog = false; 
+        });
+    }
+    else {
+        sqlString += ToSql(dbOpes, sqlRequest);
+        if (dbOpes.hasOwnProperty('appLog') && dbOpes.appLog === false) appLog = false;
+    }
+
+    sqlString = normalizeSpecialName(sqlString);
+
+    // Log
+    if (appLog) {
+        log(sqlString, 50);
+        log(JSON.stringify(dbOpes), 60);
+    }
+
+    // Run query
+    const sqlresult = await sqlRequest.query(sqlString);
+
+    // normalize return object
+    const _return = normalizeQueryResults(sqlresult);
+
+    // Log
+    if (appLog) {
+        if (Array.isArray(dbOpes)) // multiple query 
+            log(`Batch return ${Number.isInteger(_return) ? _return : Array.isArray(_return) ? _return.length : _return ? 1 : 0} result(s).`, 50)
+        else
+            log(`Query result: ${Number.isInteger(_return) ? _return : Array.isArray(_return) ? _return.length : _return ? 1 : 0} row(s).`, 50)
+    }
+
+    // return
+    return rawResult ? sqlresult : _return;
+
+}
+
+// Normalize SQL to replace backticks with square brackets, considering quoted strings
+function normalizeSpecialName(sqlString) {
+    let result = "";
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let msSqlOpening = true; // Serve per alternare [ e ] in modalità mssql
+
+    for (let i = 0; i < sqlString.length; i++) {
+        const char = sqlString[i];
+
+        // Gestione delle stringhe (costanti)
+        if (char === "'" && !inDoubleQuote) {
+            inSingleQuote = !inSingleQuote;
+        } else if (char === '"' && !inSingleQuote) {
+            inDoubleQuote = !inDoubleQuote;
+        }
+
+        // Se siamo fuori dalle citazioni, applichiamo la logica di conversione
+        if (!inSingleQuote && !inDoubleQuote) {
+            if (char === '`') {
+                result += msSqlOpening ? '[' : ']';
+                msSqlOpening = !msSqlOpening; // Alterna per il prossimo backtick
+                continue;
+            }
+        }
+
+        result += char;
+    }
+
+    return result;
+}
+
+// Compose fully qualified table name
+function fullyQualifiedTableName(tSchema) {
+    return (tSchema.database.realName + '.' + (tSchema.table.schema ?? '') + '.' + tSchema.table.realName);
+}
+
+function containLIMIT(s) {
+    const _return = s?.match(_match_LIMIT_n);
+    if (_return) return _return[0];
+    else return undefined;
+};
+
+function replaceLIMITToTOP(s) {
+    const _replace = containLIMIT(s);
+    if (_replace) { return s.replace(_match_LIMIT_n, _replace.replace(_match_LIMIT, 'TOP')); }
+    else return s;
+}
+
+/**
+ * Normalizza query results mssql.
+ * @param {Object} result - L'oggetto restituito da request.query() o request.execute()
+ * @returns {Array|number|Array<Array|number>} Risultati normalizzati
+ */
+function normalizeQueryResults(result) {
+    // 1. Gestione Batch / Multiple Statements
+    // Se ci sono più recordset o più conteggi di righe colpite
+    if (result.recordsets && result.recordsets.length > 1) {
+        return result.recordsets.map((set, index) => {
+            if (set.length > 0) {
+                return set; // Restituisce l'array di record per questa specifica query
+            }
+            // Se il recordset è vuoto, controlliamo se c'è un conteggio di righe per questa posizione
+            return result.rowsAffected[index] || 0;
+        });
+    }
+
+    // 2. Query SELECT singola
+    // Se recordset esiste ed è popolato, restituiamo i dati
+    if (result.recordset && result.recordset.length > 0) {
+        return result.recordset;
+    }
+
+    // 3. Query di Modifica singola (INSERT, UPDATE, DELETE)
+    // Se non ci sono record, restituiamo il totale delle righe colpite
+    if (result.rowsAffected && result.rowsAffected.length === 1) {
+        return result.rowsAffected[0];
+    }
+
+    // Fallback: se la SELECT non ha prodotto risultati, restituiamo un array vuoto
+    return result.recordset || [];
+}
+
+// Parse oprations object to sql string
+function ToSql(dbOpe, sqlRequest) {
+    if (dbOpe.get) return getToSql(dbOpe, sqlRequest);
+    if (dbOpe.post) return postToSql(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.command) return commandToSql(dbOpe, sqlRequest);
+    if (dbOpe.begin) return beginToSql(dbOpe, sqlRequest);
+    if (dbOpe.commit) return commitToSql(dbOpe, sqlRequest);
+    if (dbOpe.passthrough) return passthroughToSql(dbOpe, sqlRequest);
+    throw new Error('Sintax error, missing property get/post/patch/put/delete/...');
+}
+
+// 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'
+
+    if (dbOpe.get.options && dbOpe.get.options.length > 0) {
+        if (Array.isArray(dbOpe.get.options)) { for (const s of dbOpe.get.options) { result += ' ' + replaceLIMITToTOP(s); } }
+        else result += ' ' + replaceLIMITToTOP(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.groupBy && dbOpe.get.groupBy.length > 0) {
+        if (Array.isArray(dbOpe.get.groupBy)) result += ' group by ' + dbOpe.get.groupBy.join(', ');
+        else result += ' group by ' + dbOpe.get.groupBy;
+    }
+
+    if (dbOpe.get.groupFilters && dbOpe.get.groupFilters.length > 0) {
+        if (Array.isArray(dbOpe.get.groupFilters)) result += ' having ' + dbOpe.get.groupFilters.join(' ');
+        else result += ' having ' + dbOpe.get.groupFilters;
+    }
+
+    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;
+    }
+
+    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.values) {
+        result += ' set ' + Object.entries(dbOpe.patch.values).map(e => { return e[0] + '=' + stringifyValue(e[0], e[1], dbOpe.patch.schema) }).join(', ');
+    }
+    else { throw new Error('values 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 post operation object to sql string
+function postToSql(dbOpe, sqlRequest) {
+    let result = 'insert into ' + fullyQualifiedTableName(dbOpe.post.schema);
+
+    if ((dbOpe.post.values) && (Object.keys(dbOpe.post.values).length > 0)) {
+        let result_f = ' ('; 
+        let result_v = ' values (';
+        let _first = true;
+        for (const [key, value] of Object.entries(dbOpe.post.values)) {
+            if (!_first) { 
+                result_f += ', '; 
+                result_v += ', '; 
+            } else { 
+                _first = false 
+            }
+            if (key || value) { 
+                result_f += key; 
+                result_v += stringifyValue(key, value, dbOpe.post.schema); 
+            }
+        }
+        result_f += ')'; result_v += ')';
+        result += result_f + result_v;
+    }
+    else { throw new Error('values is missing.'); }
+
+    if (dbOpe.post.params) addParams(dbOpe.post.params, sqlRequest);
+
+    result += ';'
+
+    return result;
+}
+
+// Parse put operation object to sql string
+function putToSql(dbOpe, sqlRequest) {
+    let result = 'update ' + fullyQualifiedTableName(dbOpe.put.schema);
+
+    if (dbOpe.put.values) {
+        result += ' set ' + Object.entries(dbOpe.put.values).map(e => { return e[0] + '=' + stringifyValue(e[0], e[1], dbOpe.put.schema) }).join(', ');
+    }
+    else { throw new Error('values is missing.'); }
+
+    if (dbOpe.put.filters && dbOpe.put.filters.length > 0) {
+        if (Array.isArray(dbOpe.put.filters)) result += ' where ' + dbOpe.put.filters.join(' ');
+        else result += ' where ' + dbOpe.put.filters;
+    }
+
+    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 command operation object to sql string
+function commandToSql(dbOpe, sqlRequest) {
+    let result = "execute ";
+
+    if (dbOpe.command.schema.procedure) {
+        result += dbOpe.command.schema.procedure.command;
+        if (dbOpe.command.arguments) {
+            // if argument is string but not param, will be wrap into ''
+            result += (' ' +  [].concat(dbOpe.command.arguments).map(item => { 
+                return (typeof item === 'string' && !item.trimStart().startsWith("@")) ? `'${item}'` : item
+            }).join(', ')); 
+        }
+    }
+    else { throw new Error('missing procedure/function name.'); }
+
+    if (dbOpe.command.params) addParams(dbOpe.command.params, sqlRequest);
+
+    result += ';'
+
+    return result;
+}
+
+// Parse begin operation object to sql string
+function beginToSql(dbOpe, sqlRequest) {
+    return "BEGIN TRANSACTION;";
+}
+
+// Parse commit operation object to sql string
+function commitToSql(dbOpe, sqlRequest) {
+    return "IF @@TRANCOUNT > 0 COMMIT TRANSACTION;";
+}
+
+// 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;
+}