db-crud-api 0.2.1 → 0.3.0

package/lib/db-operations.js

@@ -1,404 +1,413 @@
-'use strict';
-
-// import modules
-import schema from './schema.js'
-import * as mssql from './mssql.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 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) {
-        const sqlresult = await mssql.query(_connection, dbOpes);
-        ////mssql.closeConnection(connection);
-        if (sqlresult.recordsets.length === 0) return;
-        if (sqlresult.recordsets.length === 1) return sqlresult.recordsets[0];
-        else return sqlresult.recordsets;
-    }
-
-    // server type not supported
-    else throw new TypeError('server type not supported');
-    
-}
-
-export function prepareConnection(schema) {
-    if (!schema.server.type || schema.server.type === serverType.mssql) {  // mssql is also the default
-        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) {
-    if (connection.serverType === serverType.mssql) { return mssql.closeConnection(connection); }
-}
-
-export function closeAllConnections() {
-    return mssql.closeAllConnections();
-}
-
-export function toStringValue(value) {
-    if (!value) return 'null';
-    if (value.trimStart().charAt(0) === '\'') return value;
-    return `\'${value}\'`;
-}
-
-export function prepareSchema(obj, objType) {
-    // eg. obj = 'systemName.dbName.tableName' or 'dbName.tableName' or 'tablename' or 'systemNme..tableName'
-    //     obj = 'systemName.dbName.spName @param1, @param2 ' or 'dbName.spName @param1' or 'spName' or 'systemNme..spName'
-    // objType = 'objectType.' (Table or StoreProcedure)
-
-    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 prepareTableSchema(tablePath) {
-    // alias for prepareSchema (will be removed soon)
-//    return prepareSchema(tablePath, objectType.table)
-//}
-
-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) {
-        // if ( !_ope?.get) { _ope = { get: { options: 'top 1000' } } }
-        _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
-        });
-    });
-    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
-    }
-};
-
-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
-            });
-        }
-        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
-    }
-};
-
-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: reqOpe.put.sets,
-                    params: reqOpe?.put.params
-                },
-                connection: connection
-            });
-        }
-        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.')
-    reqOpe.put.sets[idField(tSchema)] = idValue;
-    return {
-        put: {
-            schema: tSchema,
-            sets: reqOpe.put.sets,
-            params: reqOpe?.put?.params
-        },
-        connection: connection
-    }
-};
-
-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) {
-            if (!_ope.delete.sets) throw new Error('Request sintax error, missing "delete.sets" property.')
-            _result.push({
-                delete: {
-                    schema: tSchema,
-                    filters: _ope.delete.filters,
-                    params: _ope.delete.params
-                },
-                connection: connection
-            });
-        }
-        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, idValue) {
-    return {
-        delete: {
-            schema: tSchema,
-            filters: [idField(tSchema) + ' = ' + toStringValue(idValue)]
-        },
-        connection: connection
-    }
-};
-
-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,
-                command: pSchema.command,
-                params: _ope.params
-            },
-            connection: connection
-        });
-    });
-    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
-            });
-        }
-        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
-    }
-};
-
-export function prepareCommit(connection, reqOpe) {
-    return {
-        commit: {},
-        connection: connection
-    }
-};
-
-export function prepareRollback(connection, reqOpe) {
-    return {
-        rollback: {},
-        connection: connection
-    }
-};
+'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 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 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
+        });
+    });
+    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
+    }
+};
+
+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
+            });
+        }
+        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
+    }
+};
+
+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
+            });
+        }
+        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.')
+    reqOpe.put.sets[idField(tSchema)] = idValue;
+    return {
+        put: {
+            schema: tSchema,
+            sets: reqOpe.put.sets,
+            params: reqOpe.put.params
+        },
+        connection: connection
+    }
+};
+
+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
+            });
+        }
+        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, idValue) {
+    return {
+        delete: {
+            schema: tSchema,
+            filters: [idField(tSchema) + ' = ' + toStringValue(idValue)]
+        },
+        connection: connection
+    }
+};
+
+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
+        });
+    });
+    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
+            });
+        }
+        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
+    }
+};
+
+export function prepareCommit(connection, reqOpe) {
+    return {
+        commit: {},
+        connection: connection
+    }
+};
+
+export function prepareRollback(connection, reqOpe) {
+    return {
+        rollback: {},
+        connection: connection
+    }
+};