db-crud-api 0.3.23 → 0.3.25

package/lib/db-operations.js.bak

@@ -0,0 +1,486 @@
+'use strict';
+
+// import modules
+import schema from './schema.js'
+import * as mssql from './mssql.js';
+import * as mysql from './mysql.js';
+
+// Common
+const defautlFields = ['*'];
+export const serverType = Object.freeze({ mssql:  'ms-sql', mysql: 'my-sql', mongodb: 'mongo-db' });
+export const objectType = Object.freeze({ table:  'T', procedure: 'P' });
+
+// Exported functions 
+export function idField(tSchema) {
+    return tSchema.table?.idField ?? 'id';
+}
+
+export function autoId(tSchema) {
+    return tSchema.table?.autoId;
+}
+
+export function getProperty(obj, keyToFind) {
+    if (typeof obj !== 'object' || obj === null || !keyToFind) {
+        return undefined;
+    }
+
+    const lowerKeyToFind = keyToFind.toLowerCase();
+
+    for (const key in obj) {
+        // Usa hasOwnProperty per escludere le proprietà ereditate
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+
+            if (key.toLowerCase() === lowerKeyToFind) {
+                return obj[key];
+            }
+        }
+    }
+
+    return undefined;
+}
+
+export function upsertProperty(obj, keyToUpdate, newValue) {
+    if (typeof obj !== 'object' || obj === null) {
+        // Non è un oggetto valido
+        return false;
+    }
+
+    const lowerKeyToUpdate = keyToUpdate.toLowerCase();
+    let propertyFound = false;
+
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if (key.toLowerCase() === lowerKeyToUpdate) {
+                obj[key] = newValue;
+                propertyFound = true;
+                break;
+            }
+        }
+    }
+
+    if (!propertyFound) {
+        obj[keyToUpdate] = newValue;
+    }
+
+    return true;
+}
+
+export async function runQuery(dbOpes) {
+
+    // all connections must have same id
+    const _connection = Array.isArray(dbOpes) ? dbOpes[0].connection : dbOpes.connection;
+    if (Array.isArray(dbOpes)) {
+        for (let i = 1; i < dbOpes.length; i++) {
+            if (dbOpes[i].connection?.id !== _connection.id) throw new TypeError('runQuery: for multiple operations, connection must be the same');
+        }
+    }
+    
+    // MSSQL
+    if (_connection.serverType === serverType.mssql) {
+        return await mssql.query(_connection, dbOpes);
+    }
+
+    // MySQL
+    else if (_connection.serverType === serverType.mysql) {
+        return await mysql.query(_connection, dbOpes);
+    }
+    
+    // server type not supported
+    else throw new TypeError('server type not supported');
+    
+}
+
+export function prepareConnection(schema) {
+    // MySQL
+    if (schema.server.type === serverType.mysql) {
+        const _return = mysql.prepareConnection(schema);
+        _return.serverType = serverType.mysql;  // append 'serverType' to connection
+        return _return;
+    }
+    // MSSQL is also the default
+    if (!schema.server.type || schema.server.type === serverType.mssql) { 
+        const _return = mssql.prepareConnection(schema);
+        _return.serverType = serverType.mssql;  // append 'serverType' to connection
+        return _return;
+    }
+    throw new TypeError('server type not supported');
+}
+
+export function closeConnection(connection) {
+    // MSSQL
+    if (connection.serverType === serverType.mssql) { return mssql.closeConnection(connection); }
+    // MySQL
+    if (connection.serverType === serverType.mysql) { return mysql.closeConnection(connection); }
+}
+
+export function closeAllConnections() {
+    // MSSQL
+    mssql.closeAllConnections();
+    // MySQL
+    mysql.closeAllConnections();
+
+    return;
+}
+
+export function testConnection() {
+    const _connection = prepareConnection(prepareSchema("test", objectType.procedure));
+    // MSSQL
+    if (_connection.serverType === serverType.mssql) { return mssql.testConnection(_connection); }
+    // MySQL
+    if (_connection.serverType === serverType.mysql) { return mysql.testConnection(_connection); }
+    // server type not supported
+    throw new TypeError('server type not supported');
+}
+
+export function toStringValue(value) {
+    if (!value) return 'null';
+    if (value.trimStart().charAt(0) === '\'') return value;
+    return `\'${value}\'`;
+}
+
+export function prepareSchema(obj, objType) {
+    // objType = 'objectType.' (Table or StoreProcedure)
+    //     obj = 'systemName.dbName.objName' or 'dbName.objName' or 'objName' or 'systemNme..objName'
+
+    if (obj == undefined || typeof obj !== 'string') throw new TypeError('prepareSchema: wrong obj');
+    if (objType !== undefined && objType !== objectType.table && objType !== objectType.procedure) throw new TypeError(`prepareSchema: wrong objType, must be ${objectType.join(', ')}`);
+    const objPath = obj.trimStart().split(' ')[0];
+
+    // split objPath to serverName,dbName,objName
+    let serverName = undefined;
+    let dbName = undefined;
+    let objName = undefined;
+    const objPathArray = objPath.split('.');
+    if (objPathArray.length > 2) {
+        serverName = objPathArray[0]
+        dbName = objPathArray[1]
+        objName = objPathArray[2]
+    }
+    else if (objPathArray.length > 1) {
+        dbName = objPathArray[0]
+        objName = objPathArray[1]
+    }
+    else if (objPathArray.length > 0) {
+        objName = objPathArray[0]
+    }
+
+    // server
+    if (!serverName || serverName.length == 0) {
+        if (!schema.servers || !Object.keys(schema.servers)[0]) throw new TypeError('missing default server in dbSchema');
+        serverName = Object.keys(schema.servers)[0];
+    }
+    else { // add server to schema 
+        if (!schema.servers) { schema.servers = {} };
+        if (!schema.servers[serverName]) { schema.servers[serverName] = {} };
+    }
+    if (!schema.servers[serverName].realName) { schema.servers[serverName].realName = serverName } // add realName
+
+    // database
+    if (!dbName || dbName.length == 0) {
+        if (!schema.servers[serverName].databases || !Object.keys(schema.servers[serverName].databases)[0]) throw new TypeError('missing default database in dbSchema');
+        dbName = Object.keys(schema.servers[serverName].databases)[0];
+    }
+    else { // add db to schema
+        if (!schema.servers[serverName].databases) { schema.servers[serverName].databases = {} };
+        if (!schema.servers[serverName].databases[dbName]) { schema.servers[serverName].databases[dbName] = {} };
+    }
+    if (!schema.servers[serverName].databases[dbName].realName) { schema.servers[serverName].databases[dbName].realName = dbName } // add realName
+
+    // table
+    if (objType === objectType.table || objType == undefined) {
+        if (!objName || objName.length == 0) {
+            if (!schema.servers[serverName].databases[dbName] || !Object.keys(schema.servers[serverName].databases[dbName].tables)[0]) throw new TypeError('missing default table in dbSchema');
+            objName = Object.keys(schema.servers[serverName].databases[dbName].tables)[0];
+        }
+        else { // add table to schema
+            if (!schema.servers[serverName].databases[dbName].tables) { schema.servers[serverName].databases[dbName].tables = {} };
+            if (!schema.servers[serverName].databases[dbName].tables[objName]) { schema.servers[serverName].databases[dbName].tables[objName] = {} }
+        }
+        if (!schema.servers[serverName].databases[dbName].tables[objName].realName) { schema.servers[serverName].databases[dbName].tables[objName].realName = objName } // add realName
+    }
+
+    // store procedure
+    if (objType === objectType.procedure) {
+        if (!objName || objName.length == 0) {
+            if (!schema.servers[serverName].databases[dbName] || !Object.keys(schema.servers[serverName].databases[dbName].procedures)[0]) throw new TypeError('missing default procedure in dbSchema');
+            objName = Object.keys(schema.servers[serverName].databases[dbName].procedures)[0];
+        }
+        else { // add storeprocedure to schema
+            if (!schema.servers[serverName].databases[dbName].procedures) { schema.servers[serverName].databases[dbName].procedures = {} };
+            if (!schema.servers[serverName].databases[dbName].procedures[objName]) { schema.servers[serverName].databases[dbName].procedures[objName] = {command: obj} }
+        }
+        if (!schema.servers[serverName].databases[dbName].procedures[objName].realName) { schema.servers[serverName].databases[dbName].procedures[objName].realName = objName } // add realName
+    }
+
+    // return Schema
+    return {
+        table: (objType == undefined || objType === objectType.table) ? schema.servers[serverName].databases[dbName].tables[objName] : undefined,
+        procedure:  (objType === objectType.procedure) ? schema.servers[serverName].databases[dbName].procedures[objName] : undefined,
+        database: schema.servers[serverName].databases[dbName],
+        server: schema.servers[serverName]
+    }
+
+}
+
+export function prepareRun(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.get) _result.push(prepareGet(tSchema, connection, _ope));
+        else if (_ope?.patch) _result.push(preparePatch(tSchema, connection, _ope));
+        else if (_ope?.put) _result.push(preparePut(tSchema, connection, _ope));
+        else if (_ope?.delete) _result.push(prepareDelete(tSchema, connection, _ope));
+        else if (_ope?.execute) _result.push(prepareExecute(connection, _ope));
+        else if (_ope?.begin) _result.push(prepareBegin(connection, _ope));
+        else if (_ope?.commit) _result.push(prepareCommit(connection, _ope));
+        else if (_ope?.rollback) _result.push(prepareRollback(connection, _ope));
+        else if (_ope?.passthrough) _result.push(preparePassthrough(connection, _ope));
+        else throw new Error('Request sintax error, missing property get/patch/put/delete/...');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+}
+
+export function prepareRunById(tSchema, connection, reqOpe, idValue) {
+    if (reqOpe?.get) return prepareGetById(tSchema, connection, reqOpe, idValue);
+    if (reqOpe?.patch) return preparePatchById(tSchema, connection, reqOpe, idValue);
+    if (reqOpe?.put) return preparePutById(tSchema, connection, reqOpe, idValue);
+    if (reqOpe?.delete) return prepareDeleteById(tSchema, connection, reqOpe, idValue);
+    else throw new Error('Request sintax error, missing property get/patch/put/delete...');
+}
+
+export function prepareGet(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        _result.push({
+            get: {
+                schema: tSchema,
+                options: _ope?.get?.options,
+                fields: _ope?.get?.fields ?? defautlFields,
+                filters: _ope?.get?.filters,
+                groups: _ope?.get?.groups,
+                groupsFilters: _ope?.get?.groupsFilters,
+                orderBy: _ope?.get?.orderBy,
+                params: _ope?.get?.params
+            },
+            connection: connection,
+            appLog: _ope?.hasOwnProperty('appLog') ? _ope.appLog : undefined
+        });
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function prepareGetById(tSchema, connection, reqOpe, idValue) {
+    const _filters = [idField(tSchema) + ' = ' + toStringValue(idValue)];
+    if (reqOpe?.get?.filters && reqOpe?.get?.filters.length > 0) {
+        _filters.push('and');
+        Array.isArray(reqOpe.get.filters) ? _filters.push(...reqOpe.get.filters) : _filters.push(reqOpe.get.filters);
+    }
+    return {
+        get: {
+            schema: tSchema,
+            options: reqOpe?.get?.options,
+            fields: reqOpe?.get?.fields ?? defautlFields,
+            filters: _filters
+        },
+        connection: connection,
+        appLog: reqOpe?.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function preparePatch(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.patch) {
+            if (!_ope.patch.sets) throw new Error('Request sintax error, missing "patch.sets" property.')
+            _result.push({
+                patch: {
+                    schema: tSchema,
+                    sets: _ope.patch.sets,
+                    filters: _ope.patch.filters,
+                    params: _ope.patch.params
+                },
+                connection: connection,
+                appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            });
+        }
+        else throw new Error('Request sintax error, missing "patch" property.');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function preparePatchById(tSchema, connection, reqOpe, idValue) {
+    if (!reqOpe?.patch) throw new Error('Request sintax error, missing "patch" property.')
+    if (!reqOpe.patch.sets) throw new Error('Missing "patch.sets" in operation.')
+    const _filters = [idField(tSchema) + ' = ' + toStringValue(idValue)];
+    if (reqOpe?.patch?.filters && reqOpe?.patch?.filters.length > 0) {
+        _filters.push('and');
+        Array.isArray(reqOpe.patch.filters) ? _filters.push(...reqOpe.patch.filters) : _filters.push(reqOpe.patch.filters);
+    }
+    return {
+        patch: {
+            schema: tSchema,
+            sets: reqOpe.patch.sets,
+            filters: _filters
+        },
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function preparePut(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.put) {
+            if (!_ope.put.sets) throw new Error('Request sintax error, missing "put.sets" property.')
+            _result.push({
+                put: {
+                    schema: tSchema,
+                    sets: _ope.put.sets,
+                    params: _ope.put.params
+                },
+                connection: connection,
+                appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            });
+        }
+        else throw new Error('Request sintax error, missing "put" property.');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function preparePutById(tSchema, connection, reqOpe, idValue) {
+    if (!reqOpe?.put) throw new Error('Request sintax error, missing "put" property.')
+    if (!reqOpe.put.sets) throw new Error('Missing "put.sets" in operation.')
+    upsertProperty(reqOpe.put.sets, idField(tSchema), idValue);
+    return {
+        put: {
+            schema: tSchema,
+            sets: reqOpe.put.sets,
+            params: reqOpe.put.params
+        },
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function prepareDelete(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.delete) {
+            _result.push({
+                delete: {
+                    schema: tSchema,
+                    filters: _ope.delete.filters,
+                    params: _ope.delete.params
+                },
+                connection: connection,
+                appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            });
+        }
+        else throw new Error('Request sintax error, missing "delete" property.');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function prepareDeleteById(tSchema, connection, reqOpe, idValue) {
+    return {
+        delete: {
+            schema: tSchema,
+            filters: [idField(tSchema) + ' = ' + toStringValue(idValue)]
+        },
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function prepareExecute(pSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        _result.push({
+            execute: {
+                schema: pSchema,
+                arguments: _ope.execute?.arguments,
+                params: _ope.execute?.params
+            },
+            connection: connection,
+            appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+        });
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function preparePassthrough(connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.passthrough) {
+            if (!_ope.passthrough.command) throw new Error('Request sintax error, missing "passthrough.command" property.')
+            _result.push({
+                passthrough: {
+                    command: _ope.passthrough.command,
+                    params: _ope.passthrough.params
+                },
+                connection: connection,
+                appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            });
+        }
+        else throw new Error('Request sintax error, missing "passthrough" property.');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function prepareBegin(connection, reqOpe) {
+    return {
+        begin: {},
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function prepareCommit(connection, reqOpe) {
+    return {
+        commit: {},
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function prepareRollback(connection, reqOpe) {
+    return {
+        rollback: {},
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};

package/lib/mssql.js

@@ -131,21 +131,34 @@ export async function query(connection, dbOpes) {
     // 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); });
-    else sqlString += ToSql(dbOpes, sqlRequest);
+    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
-    log(sqlString, 50);
-    log(JSON.stringify(dbOpes), 60);
-    
+    if (appLog) {
+        log(sqlString, 50);
+        log(JSON.stringify(dbOpes), 60);
+    }
+
     // Run query
     const sqlresult = await sqlRequest.query(sqlString);
 
     // Log
-    log(`Query result: ${sqlresult.recordset ? sqlresult.recordset.length : 0} rows.`, 50);
+    if (appLog) {
+        log(`Query result: ${sqlresult.recordset ? sqlresult.recordset.length : 0} rows.`, 50);
+    }
 
     // normalize return object
     if (sqlresult.recordset == undefined) return;

package/lib/mysql.js

@@ -83,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
     }
 }
@@ -94,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
         }
     }
@@ -125,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;
@@ -146,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;