db-crud-wrapper 1.0.1

package/lib/db-operations.js

@@ -0,0 +1,426 @@
+'use strict';
+
+// import modules
+import { v4 as uuidv4 } from 'uuid';
+import { config } from './config.js';
+import * as f from './f.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;
+}
+
+function normalizeReqOperations(reqOpe) {
+    if (Array.isArray(reqOpe)) return reqOpe;
+    if (reqOpe === undefined || reqOpe === null) return [];
+    return [reqOpe];
+}
+
+function denormalizePreparedOperations(prepared, wasArrayInput) {
+    if (wasArrayInput) return prepared;
+    return prepared.length > 0 ? prepared[0] : undefined;
+}
+
+function mergeByIdFilters(filters, idFilter) {
+    if (!filters || (Array.isArray(filters) && filters.length === 0)) return [idFilter];
+    if (Array.isArray(filters)) return [idFilter, 'and', ...filters];
+    return [idFilter, 'and', filters];
+}
+
+export async function runQuery(dbOpes, rawResult = false) {
+
+    // 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, rawResult);
+    }
+
+    // MySQL
+    else if (_connection.serverType === serverType.mysql) {
+        return await mysql.query(_connection, dbOpes, rawResult);
+    }
+    
+    // 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 async function closeConnection(connection) {
+    // MSSQL
+    if (connection.serverType === serverType.mssql) { return mssql.closeConnection(connection); }
+    // MySQL
+    if (connection.serverType === serverType.mysql) { return mysql.closeConnection(connection); }
+}
+
+export async function closeAllConnections() {
+    // MSSQL
+    await mssql.closeAllConnections();
+    // MySQL
+    await 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 (typeof value === 'string' && value.trimStart().charAt(0) === '\'') return value;
+    return `\'${value}\'`;
+}
+
+export function prepareSchema(obj, objType) {
+    // objType = must be 'objectType.*' or undefined/null
+    //     obj = 'systemName.dbName.objName' or 'dbName.objName' or 'objName' or 'systemNme..objName or undefined/null'
+
+    if (obj && typeof obj !== 'string') throw new TypeError('prepareSchema: obj must be a string');
+    if (objType && objType !== objectType.table && objType !== objectType.procedure) throw new TypeError(`prepareSchema: wrong objType, must be ${objectType.join(', ')}`);
+    const objPath = obj ? obj.trimStart().split(' ')[0] : undefined;
+
+    let serverName = undefined;
+    let dbName = undefined;
+    let objName = undefined;
+
+    // split objPath to serverName,dbName,objName
+    if (objPath) { 
+        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 (!config.servers || !Object.keys(config.servers)[0]) throw new TypeError('missing default server.');
+        serverName = Object.keys(config.servers)[0];
+    }
+    else { // add server to schema 
+        if (!config.servers) { config.servers = {} };
+        if (!config.servers[serverName]) { config.servers[serverName] = {} };
+    }
+    if (!config.servers[serverName].realName) { config.servers[serverName].realName = serverName } // add realName
+
+    // database
+    if (!dbName || dbName.length == 0) {
+        if (!config.servers[serverName].databases || !Object.keys(config.servers[serverName].databases)[0]) throw new TypeError('missing default database.');
+        dbName = Object.keys(config.servers[serverName].databases)[0];
+    }
+    else { // add db to schema
+        if (!config.servers[serverName].databases) { config.servers[serverName].databases = {} };
+        if (!config.servers[serverName].databases[dbName]) { config.servers[serverName].databases[dbName] = {} };
+    }
+    if (!config.servers[serverName].databases[dbName].realName) { config.servers[serverName].databases[dbName].realName = dbName } // add realName
+
+    // table
+    if (objType === objectType.table) {
+        if (!objName || objName.length == 0) {
+            if (!config.servers[serverName].databases[dbName] || !Object.keys(config.servers[serverName].databases[dbName].tables)[0]) throw new TypeError('missing default table in dbSchema');
+            objName = Object.keys(config.servers[serverName].databases[dbName].tables)[0];
+        }
+        else { // add table to schema
+            if (!config.servers[serverName].databases[dbName].tables) { config.servers[serverName].databases[dbName].tables = {} };
+            if (!config.servers[serverName].databases[dbName].tables[objName]) { config.servers[serverName].databases[dbName].tables[objName] = {} }
+        }
+        if (!config.servers[serverName].databases[dbName].tables[objName].realName) { config.servers[serverName].databases[dbName].tables[objName].realName = objName } // add realName
+    }
+
+    // store procedure
+    if (objType === objectType.procedure) {
+        if (!objName || objName.length == 0) {
+            throw new TypeError('missing procedure name.');
+        }
+        else { // add storeprocedure to schema
+            if (!config.servers[serverName].databases[dbName].procedures) { config.servers[serverName].databases[dbName].procedures = {} };
+            if (!config.servers[serverName].databases[dbName].procedures[objName]) { config.servers[serverName].databases[dbName].procedures[objName] = {command: obj} }
+        }
+        if (!config.servers[serverName].databases[dbName].procedures[objName].realName) { config.servers[serverName].databases[dbName].procedures[objName].realName = objName } // add realName
+    }
+
+    // return Schema
+    return {
+        table: (objType === objectType.table) ? config.servers[serverName].databases[dbName].tables[objName] : undefined,
+        procedure:  (objType === objectType.procedure) ? config.servers[serverName].databases[dbName].procedures[objName] : undefined,
+        database: config.servers[serverName].databases[dbName],
+        server: config.servers[serverName]
+    }
+
+}
+
+export function prepareRun(tSchema, connection, reqOpe) {
+    const _isArrayInput = Array.isArray(reqOpe);
+    const _reqOpes = normalizeReqOperations(reqOpe);
+    const _result = _reqOpes.map((_ope) => {
+        if (_ope?.get) return prepareGet(tSchema, connection, _ope);
+        else if (_ope?.post) return preparePost(tSchema, connection, _ope);
+        else if (_ope?.patch) return preparePatch(tSchema, connection, _ope);
+        else if (_ope?.put) return preparePut(tSchema, connection, _ope);
+        else if (_ope?.delete) return prepareDelete(tSchema, connection, _ope);
+        else if (_ope?.command) return prepareCommand(tSchema, connection, _ope);
+        else if (_ope?.begin) return prepareBegin(connection, _ope);
+        else if (_ope?.commit) return prepareCommit(connection, _ope);
+        else if (_ope?.rollback) return prepareRollback(connection, _ope);
+        else if (_ope?.passthrough) return preparePassthrough(connection, _ope);
+        else throw new Error('Request sintax error, missing property get/post/patch/put/delete/...');
+    });
+    return denormalizePreparedOperations(_result, _isArrayInput);
+}
+
+export function prepareGet(tSchema, connection, reqOpe) {
+    const _isArrayInput = Array.isArray(reqOpe);
+    const _reqOpes = normalizeReqOperations(reqOpe);
+    const _result = _reqOpes.map((_ope) => {
+        const _get = _ope?.get ?? {};
+        const { byId, ...__get } = _get;  // remove byId and create a copy
+        const mergedFilters = byId ? mergeByIdFilters(__get.filters, idField(tSchema) + ' = ' + toStringValue(byId)) : __get.filters;
+        return {
+            get: {
+                schema: tSchema,
+                options: __get.options,
+                fields: __get.fields ?? defautlFields,
+                filters: mergedFilters,
+                groupBy: __get.groupBy,
+                groupFilters: __get.groupFilters,
+                orderBy: __get.orderBy,
+                params: __get.params
+            },
+            connection: connection,
+            appLog: _ope?.hasOwnProperty('appLog') ? _ope.appLog : undefined
+        };
+    });
+    return denormalizePreparedOperations(_result, _isArrayInput);
+};
+
+export function preparePatch(tSchema, connection, reqOpe) {
+    const _isArrayInput = Array.isArray(reqOpe);
+    const _reqOpes = normalizeReqOperations(reqOpe);
+    const _result = _reqOpes.map((_ope) => {
+        const _patch = _ope?.patch;
+        if (_patch) {
+            if (!_patch.values) throw new Error('Request sintax error, missing "patch.values" property.')
+            const { byId, ...__patch } = _patch; // remove byId and create a copy
+            const mergedFilters = byId ? mergeByIdFilters(__patch.filters, idField(tSchema) + ' = ' + toStringValue(byId)) : __patch.filters;
+            return {
+                patch: {
+                    schema: tSchema,
+                    values: __patch.values,
+                    filters: mergedFilters,
+                    params: __patch.params
+                },
+                connection: connection,
+                appLog: _ope?.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            };
+        }
+        else throw new Error('Request sintax error, missing "patch" property.');
+    });
+    return denormalizePreparedOperations(_result, _isArrayInput);
+};
+
+export function preparePost(tSchema, connection, reqOpe) {
+    const _isArrayInput = Array.isArray(reqOpe);
+    const _reqOpes = normalizeReqOperations(reqOpe);
+    const _result = _reqOpes.map((_ope) => {
+        const _post = _ope?.post;
+        if (_post) {
+            if (!_post.values) throw new Error('Request sintax error, missing "post.values" property.');
+            if (_post.byId) {  // force Id value from byId
+                f.upsertProperty(_post.values, idField(tSchema), _post.byId);
+            }
+            if (autoId(tSchema))  // automatic Id
+                if (!Object.keys(_post.values).find(key => key.toUpperCase() === (idField(tSchema)).toUpperCase())) {
+                    _post.values[idField(tSchema)] = uuidv4();  // automatic Id via uuidv4
+                }
+            return {
+                post: {
+                    schema: tSchema,
+                    values: _post.values,
+                    params: _post.params
+                },
+                connection: connection,
+                appLog: _ope?.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            };
+        }
+        else throw new Error('Request sintax error, missing "post" property.');
+    });
+    return denormalizePreparedOperations(_result, _isArrayInput);
+};
+
+export function preparePut(tSchema, connection, reqOpe) {
+    const _isArrayInput = Array.isArray(reqOpe);
+    const _reqOpes = normalizeReqOperations(reqOpe);
+    const _result = _reqOpes.map((_ope) => {
+        const _put = _ope?.put;
+        if (_put) {
+            if (!_put.values) throw new Error('Request sintax error, missing "put.values" property.');
+            const { byId, ...__put } = _put; // remove byId and create a copy
+            const mergedFilters = byId ? mergeByIdFilters(__put.filters, idField(tSchema) + ' = ' + toStringValue(byId)) : __put.filters;
+            return {
+                put: {
+                    schema: tSchema,
+                    values: _put.values,
+                    filters: mergedFilters,
+                    params: _put.params
+                },
+                connection: connection,
+                appLog: _ope?.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            };
+        }
+        else throw new Error('Request sintax error, missing "put" property.');
+    });
+    return denormalizePreparedOperations(_result, _isArrayInput);
+};
+
+export function prepareDelete(tSchema, connection, reqOpe) {
+    const _isArrayInput = Array.isArray(reqOpe);
+    const _reqOpes = normalizeReqOperations(reqOpe);
+    const _result = _reqOpes.map((_ope) => {
+        const _delete = _ope?.delete;
+        if (_delete) {
+            const { byId, ...__delete } = _delete; // remove byId and create a copy
+            const mergedFilters = byId ? mergeByIdFilters(__delete.filters, idField(tSchema) + ' = ' + toStringValue(byId)) : __delete.filters;
+            return {
+                delete: {
+                    schema: tSchema,
+                    filters: mergedFilters,
+                    params: __delete.params
+                },
+                connection: connection,
+                appLog: _ope?.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            };
+        }
+        else throw new Error('Request sintax error, missing "delete" property.');
+    });
+    return denormalizePreparedOperations(_result, _isArrayInput);
+};
+
+export function prepareCommand(pSchema, connection, reqOpe) {
+    const _isArrayInput = Array.isArray(reqOpe);
+    const _reqOpes = normalizeReqOperations(reqOpe);
+    const _result = _reqOpes.map((_ope) => {
+        return {
+            command: {
+                schema: pSchema,
+                arguments: Array.isArray(_ope.command?.arguments) ? _ope.command?.arguments : [_ope.command?.arguments],
+                params: _ope.command?.params
+            },
+            connection: connection,
+            appLog: _ope?.hasOwnProperty('appLog') ? _ope.appLog : undefined
+        };
+    });
+    return denormalizePreparedOperations(_result, _isArrayInput);
+};
+
+export function preparePassthrough(connection, reqOpe) {
+    const _isArrayInput = Array.isArray(reqOpe);
+    const _reqOpes = normalizeReqOperations(reqOpe);
+    const _result = _reqOpes.map((_ope) => {
+        if (_ope?.passthrough) {
+            if (!_ope.passthrough.command) throw new Error('Request sintax error, missing "passthrough.command" property.')
+            return {
+                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.');
+    });
+
+    return denormalizePreparedOperations(_result, _isArrayInput);
+};
+
+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/f.js

@@ -0,0 +1,45 @@
+"use strict";
+
+// set a deep object creating all intermediate structure
+export function setDeep(obj, path, value) {
+  const keys = path.split('.');
+  let lastKey = keys.pop();
+  let pointer = obj;
+
+  for (let key of keys) {
+    if (!pointer[key] || typeof pointer[key] !== 'object') {
+      pointer[key] = {}; // Crea l'oggetto intermedio se non esiste
+    }
+    pointer = pointer[key];
+  }
+
+  pointer[lastKey] = value;
+  return obj;
+}
+
+// upsert property using unsensitive case name.
+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;
+}

package/lib/factory.js

@@ -0,0 +1,89 @@
+"use strict";
+
+import { config, Server, Database, Table, Field, Log } from './config.js';
+import * as dbOpe from "./db-operations.js" 
+import newSessionStore from "./session-store.js"
+import { DeleteBuilder, GetBuilder, PatchBuilder, PutBuilder, PostBuilder, CommandBuilder, BatchBuilder, parseObject, PassthroughBuilder } from "./builder.js"
+
+export function command(command) {
+    return new CommandBuilder(command);
+}
+
+export function get(tablePath) {
+    return new GetBuilder(tablePath);
+}
+
+export function post(tablePath) {
+    return new PostBuilder(tablePath);
+}
+
+export function put(tablePath) {
+    return new PutBuilder(tablePath);
+}
+
+export function patch(tablePath) {
+    return new PatchBuilder(tablePath);
+}
+
+export function del(tablePath) {
+    return new DeleteBuilder(tablePath);
+}
+
+export function fromObject(obj) {
+    return parseObject(obj);
+}
+
+export function Batch() {
+    return new BatchBuilder();
+}
+
+export function Passthrough(command) {
+    return new PassthroughBuilder(command);
+}
+
+export function closeAllDbConnections() {
+    return dbOpe.closeAllConnections();
+}
+
+export function sessionStore(options) {
+    return new newSessionStore(options);
+}
+
+export function testDbConnection() {
+    return dbOpe.testConnection();
+}
+
+export function setLogLevel(level) {
+    if (typeof level === 'number') { config.log.level = level } 
+    else if (typeof level === 'string' && Number.parseInt(level) != NaN) { config.log.level = Number.parseInt(level) }
+}
+
+export function setLogCallback(callback) {
+    if (typeof callback === 'function') { config.log.callback = callback }
+}
+
+export function setLogMaxAsyncInstances(maxAsyncInstances) {
+    if (typeof maxAsyncInstances === 'number') { config.log.maxAsyncInstance = maxAsyncInstances } 
+    else if (typeof maxAsyncInstances === 'string' && Number.parseInt(maxAsyncInstances) != NaN) { config.log.maxAsyncInstance = Number.parseInt(maxAsyncInstances) }
+}
+
+export function log() {
+    return new Log();
+}
+
+
+export function server(server) {
+    return new Server(server);
+}
+
+export function database(database, serverName) {
+    return new Database(database, serverName);
+}
+
+export function table(table, dbName, serverName) {
+    return new Table(table, dbName, serverName);
+}
+
+export function field(field, tableName, dbName, serverName) {
+    return new Field(field, tableName, dbName, serverName);
+}

package/lib/log.js

@@ -0,0 +1,21 @@
+'use strict';
+
+import { config } from './config.js';
+let numberOfAsyncInstances = 0;
+
+export default function log(msg, level = 1) {
+    if (config.log.level >= level && config.log.callback) {
+        try {
+            const _param = {level: level, text: msg}; 
+            const _result = config.log.callback(_param);
+            if (_result && typeof _result.then === 'function') {
+                // È una Promise (o un oggetto thenable)
+                if (numberOfAsyncInstances <= config.log.maxAsyncInstance) {
+                    numberOfAsyncInstances++;
+                    _result.then((_param) => {}).catch(error => {}).finally(() => {numberOfAsyncInstances--;});
+                };
+            };
+        }
+        catch {}
+    }
+};