@blazedpath/commons 0.0.8 → 0.0.9

package/blz-math/index.js

@@ -1,131 +1,133 @@
 module.exports = {
-    abs: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.abs(value);
-    },
-    acos: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.acos(value);
-    },
-    asin: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.asin(value);
-    },
-    atan: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.atan(value);
-    },
-    atan2: function (valueX, valueY) {
-        if (valueX === null || valueX === undefined)
-            return null;
-        if (valueY === null || valueY === undefined)
-            return null;
-        return Math.atan(valueY, valueX);
-    },
-    ceil: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.ceil(value);
-    },
-    cos: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.cos(value);
-    },
-    cosh: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.cosh(value);
-    },
-    exp: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.exp(value);
-    },
-    floor: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.floor(value);
-    },
-    log: function (value, base) {
-        if (value === null || value === undefined)
-            return null;
-        if (base)
-            return Math.log(value) / Math.log(base);
-        else
-            return Math.log(value);
-    },
-    log10: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.log10(value);
-    },
-    pow: function (value, power) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.pow(value, power ? power : 0);
-    },
-    random: function () {
-        if (typeof window !== 'undefined') {
-            let crypto = window.crypto || window.msCrypto;
-            var array = new Uint32Array(2);
-            crypto.getRandomValues(array);
-            let mantissa = (array[0] * Math.pow(2, 20)) + (array[1] >>> 12);
-            return mantissa * Math.pow(2, -52);
+    Dual: {
+        abs: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.abs(value);
+        },
+        acos: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.acos(value);
+        },
+        asin: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.asin(value);
+        },
+        atan: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.atan(value);
+        },
+        atan2: function (valueX, valueY) {
+            if (valueX === null || valueX === undefined)
+                return null;
+            if (valueY === null || valueY === undefined)
+                return null;
+            return Math.atan(valueY, valueX);
+        },
+        ceil: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.ceil(value);
+        },
+        cos: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.cos(value);
+        },
+        cosh: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.cosh(value);
+        },
+        exp: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.exp(value);
+        },
+        floor: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.floor(value);
+        },
+        log: function (value, base) {
+            if (value === null || value === undefined)
+                return null;
+            if (base)
+                return Math.log(value) / Math.log(base);
+            else
+                return Math.log(value);
+        },
+        log10: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.log10(value);
+        },
+        pow: function (value, power) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.pow(value, power ? power : 0);
+        },
+        random: function () {
+            if (typeof window !== 'undefined') {
+                let crypto = window.crypto || window.msCrypto;
+                var array = new Uint32Array(2);
+                crypto.getRandomValues(array);
+                let mantissa = (array[0] * Math.pow(2, 20)) + (array[1] >>> 12);
+                return mantissa * Math.pow(2, -52);
+            }
+            else {
+                let crypto = require('crypto');
+                return crypto.randomBytes(4).readUInt32BE(0) / 4294967296;
+            }
+        },
+        round: function (value, decimals) {
+            if (value === null || value === undefined)
+                return null;
+            if (decimals)
+                return Math.round(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
+            else
+                return Math.round(value);
+        },
+        sign: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.sign(value);
+        },
+        sin: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.sin(value);
+        },
+        sinh: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.sinh(value);
+        },
+        sqrt: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.sqrt(value);
+        },
+        tan: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.tan(value);
+        },
+        tanh: function (value) {
+            if (value === null || value === undefined)
+                return null;
+            return Math.tanh(value);
+        },
+        trunc: function (value, decimals) {
+            if (value === null || value === undefined)
+                return null;
+            if (decimals)
+                return Math.trunc(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
+            else
+                return Math.trunc(value);
         }
-        else {
-            let crypto = require('crypto');
-            return crypto.randomBytes(4).readUInt32BE(0) / 4294967296;            
-        }
-    },
-    round: function (value, decimals) {
-        if (value === null || value === undefined)
-            return null;
-        if (decimals)
-            return Math.round(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
-        else
-            return Math.round(value);
-    },
-    sign: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.sign(value);
-    },
-    sin: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.sin(value);
-    },
-    sinh: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.sinh(value);
-    },
-    sqrt: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.sqrt(value);
-    },
-    tan: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.tan(value);
-    },
-    tanh: function (value) {
-        if (value === null || value === undefined)
-            return null;
-        return Math.tanh(value);
-    },
-    trunc: function (value, decimals) {
-        if (value === null || value === undefined)
-            return null;
-        if (decimals)
-            return Math.trunc(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
-        else
-            return Math.trunc(value);
     }
 };

package/blz-mongodb/index.js

@@ -11,7 +11,7 @@ let getMongodbConnection = async function (connection) {
         // [MONGODB DRIVER] Warning: useUnifiedTopology is a deprecated option: useUnifiedTopology has no effect since Node.js Driver version 4.0.0 and will be removed in the next major version
         // mongoConfig.useUnifiedTopology = true;
         if (connection.ssl) {
-            mongoConfig.ssl = true;            
+            mongoConfig.ssl = true;
             if (connection.sslCert)
                 mongoConfig.sslCert = await convertFileArg(connection.sslCert);
             if (connection.sslCrl)
@@ -38,21 +38,21 @@ let getMongodbConnection = async function (connection) {
         }
         // start connect mongo with retry
         let mongoClient = null;
-        if (connection.useRetries){
+        if (connection.useRetries) {
             await AsyncRetry(async () => {
                 mongoClient = new MongoClient(connection.url, mongoConfig);
                 try {
-                  await mongoClient.connect();
+                    await mongoClient.connect();
                 } catch (err) {
-                  console.error('Error connecting to MongoDB:', err);
-                  throw err; // This will trigger a retry
+                    console.error('Error connecting to MongoDB:', err);
+                    throw err; // This will trigger a retry
                 } finally {
                 }
             }, {
                 retries: connection.retryCount,
                 minTimeout: connection.minRetryInterval * 1000,
                 maxTimeout: connection.maxRetryInterval * 1000,
-              });
+            });
         } else {
             mongoClient = await MongoClient.connect(connection.url, mongoConfig);
         }
@@ -97,7 +97,7 @@ let convertFromMongodb = function (value) {
             for (let i = 0; i < value.length; i++) {
                 value[i] = convertFromMongodb(value[i]);
             }
-        }        
+        }
     }
     return value;
 };
@@ -188,7 +188,7 @@ let mongodbDropIndexes = async function (connection, collectionName, options) {
 let mongodbFind = async function (connection, collectionName, query, options) {
     let mongodbConnection = await getMongodbConnection(connection);
     let mongodbCursor = await mongodbConnection.collection(collectionName).find(convertToMongodb(query), options);
-    if (mongodbCursor){
+    if (mongodbCursor) {
         const list = await mongodbCursor.map(function (mongoDbDoc) { return convertFromMongodb(mongoDbDoc); }).toArray();
         return list;
     }
@@ -298,29 +298,31 @@ let mongodbConnectionHealthCheck = async function (connection) {
 }
 
 module.exports = {
-    mongodbAggregate: mongodbAggregate,
-    mongodbBulkWrite: mongodbBulkWrite,
-    mongodbCountDocuments: mongodbCountDocuments,
-    mongodbCreateIndex: mongodbCreateIndex,
-    mongodbDeleteMany: mongodbDeleteMany,
-    mongodbDeleteOne: mongodbDeleteOne,
-    mongodbDistinct: mongodbDistinct,
-    mongodbDrop: mongodbDrop,
-    mongodbDropIndex: mongodbDropIndex,
-    mongodbDropIndexes: mongodbDropIndexes,
-    mongodbFind: mongodbFind,
-    mongodbFindOne: mongodbFindOne,
-    mongodbGeoHaystackSearch: mongodbGeoHaystackSearch,
-    mongodbIndexExists: mongodbIndexExists,
-    mongodbInsertMany: mongodbInsertMany,
-    mongodbInsertOne: mongodbInsertOne,
-    mongodbIsCapped: mongodbIsCapped,
-    mongodbListIndexes: mongodbListIndexes,
-    mongodbOptions: mongodbOptions,
-    mongodbReIndex: mongodbReIndex,
-    mongodbReplaceOne: mongodbReplaceOne,
-    mongodbStats: mongodbStats,
-    mongodbUpdateMany: mongodbUpdateMany,
-    mongodbUpdateOne: mongodbUpdateOne,
-    mongodbConnectionHealthCheck: mongodbConnectionHealthCheck
+    Backend: {
+        mongodbAggregate: mongodbAggregate,
+        mongodbBulkWrite: mongodbBulkWrite,
+        mongodbCountDocuments: mongodbCountDocuments,
+        mongodbCreateIndex: mongodbCreateIndex,
+        mongodbDeleteMany: mongodbDeleteMany,
+        mongodbDeleteOne: mongodbDeleteOne,
+        mongodbDistinct: mongodbDistinct,
+        mongodbDrop: mongodbDrop,
+        mongodbDropIndex: mongodbDropIndex,
+        mongodbDropIndexes: mongodbDropIndexes,
+        mongodbFind: mongodbFind,
+        mongodbFindOne: mongodbFindOne,
+        mongodbGeoHaystackSearch: mongodbGeoHaystackSearch,
+        mongodbIndexExists: mongodbIndexExists,
+        mongodbInsertMany: mongodbInsertMany,
+        mongodbInsertOne: mongodbInsertOne,
+        mongodbIsCapped: mongodbIsCapped,
+        mongodbListIndexes: mongodbListIndexes,
+        mongodbOptions: mongodbOptions,
+        mongodbReIndex: mongodbReIndex,
+        mongodbReplaceOne: mongodbReplaceOne,
+        mongodbStats: mongodbStats,
+        mongodbUpdateMany: mongodbUpdateMany,
+        mongodbUpdateOne: mongodbUpdateOne,
+        mongodbConnectionHealthCheck: mongodbConnectionHealthCheck
+    }
 };

package/blz-rds/index.js

@@ -3,11 +3,11 @@ const BlzRdsExecutor = require('./blz-rds-executor');
 const SqlString = require('sqlstring');
 
 
-const rdsEscapeId = function(identifier) {
+const rdsEscapeId = function (identifier) {
     return SqlString.escapeId(identifier)
 }
 
-const rdsEscape = function(value) {
+const rdsEscape = function (value) {
     return SqlString.escape(value)
 }
 
@@ -273,7 +273,7 @@ const rdsExists = async function (callContext, connection, rdsExistsConfig) {
         let value = values[i];
         parameters.push({ name: 'PARAM' + i, value: value, direction: 'in' });
     }
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, { queryOne: true }, ['boolean'], function(ctx) { return ctx[0]; });
+    let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, { queryOne: true }, ['boolean'], function (ctx) { return ctx[0]; });
     return result.data;
 };
 
@@ -296,7 +296,7 @@ const rdsInsert = async function (callContext, connection, rdsInsertConfig) {
         let set = rdsInsertConfig.sets[i];
         setsFields.push(getColumnNameByAlias(rdsTable, set.columnAlias));
         setsValues.push(BlzRdsHelper.getSql(set.value, connection.provider.syntaxis, values));
-        columns.push(rdsTable.columns.find(p=> p.alias === set.columnAlias))  
+        columns.push(rdsTable.columns.find(p => p.alias === set.columnAlias))
     }
     let autoincrementalData = null;
     if (rdsTable.autoincrementalPrimaryKey) {
@@ -340,7 +340,7 @@ const rdsInsertConditional = async function (callContext, connection, rdsInsertC
             BlzRdsHelper.prebuild(connection, set.value, embeddeds);
         }
     if (rdsInsertConfig.where)
-        BlzRdsHelper.prebuild(connection, rdsInsertConfig.where, embeddeds);    
+        BlzRdsHelper.prebuild(connection, rdsInsertConfig.where, embeddeds);
     let sql = '';
     let values = [];
     let setsFields = [];
@@ -362,7 +362,7 @@ const rdsInsertConditional = async function (callContext, connection, rdsInsertC
         err.code = 'RdsError';
         err.message = 'Table ' + rdsTable.tableName + ' does not have WHERE defined.';
         throw err;
-    }   
+    }
     let autoincrementalData = null;
     if (rdsTable.autoincrementalPrimaryKey) {
         if (connection.provider.syntaxis.insertConditionalAutoIncremental.indexOf('%2$s') !== -1 && (rdsTable.sequenceName === '' || rdsTable.sequenceName === null || rdsTable.sequenceName === undefined)) {
@@ -390,7 +390,7 @@ const rdsInsertConditional = async function (callContext, connection, rdsInsertC
     return result.id !== undefined ? result.id : null
 };
 
-const rdsBulkInsert = async function (callContext, connection, rdsInsertConfig) {    
+const rdsBulkInsert = async function (callContext, connection, rdsInsertConfig) {
     let rdsTable = connection.rdsElements[rdsInsertConfig.rdsTableName];
     let embeddeds = {};
     let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: false };
@@ -403,8 +403,8 @@ const rdsBulkInsert = async function (callContext, connection, rdsInsertConfig)
     const columns = []
     for (let i = 0; i < rdsInsertConfig.sets.length; i++) {
         let field = rdsInsertConfig.sets[i];
-        setsFields.push(getColumnNameByAlias(rdsTable, field.columnAlias))        
-        columns.push(rdsTable.columns.find(p=> p.alias === field.columnAlias))        
+        setsFields.push(getColumnNameByAlias(rdsTable, field.columnAlias))
+        columns.push(rdsTable.columns.find(p => p.alias === field.columnAlias))
     }
     for (let i = 0; i < rdsInsertConfig.list.length; i++) {
         let row = rdsInsertConfig.list[i];
@@ -428,11 +428,11 @@ const rdsBulkInsert = async function (callContext, connection, rdsInsertConfig)
         };
     }
     const sql = 'INSERT INTO ' + rdsTable.tableName + ' (' + setsFields.join(', ') + ') VALUES ';
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, values, { bulkInsert:true, autoincrementalData: autoincrementalData, columns , setsFields, rdsTable });
+    let result = await BlzRdsExecutor.execute(callContext, connection, sql, values, { bulkInsert: true, autoincrementalData: autoincrementalData, columns, setsFields, rdsTable });
     return result.ids !== undefined ? result.ids : null
 };
 
-const rdsBulkMerge = async function (callContext, connection, rdsMergeConfig) {    
+const rdsBulkMerge = async function (callContext, connection, rdsMergeConfig) {
     let rdsTable = connection.rdsElements[rdsMergeConfig.rdsTableName];
     let embeddeds = {};
     let embedded = { rdsTable: rdsTable, rdsJoins: [], allowLevels: false };
@@ -440,10 +440,10 @@ const rdsBulkMerge = async function (callContext, connection, rdsMergeConfig) {
 
     if (!rdsMergeConfig.sets || rdsMergeConfig.sets.length === 0) {
         return []
-    }    
+    }
     for (let i = 0; i < rdsMergeConfig.sets.length; i++) {
         let set = rdsMergeConfig.sets[i];
-        for (let j = 0; j < set.length; j++) {                
+        for (let j = 0; j < set.length; j++) {
             BlzRdsHelper.prebuild(connection, set[j].value, embeddeds);
         }
     }
@@ -459,13 +459,13 @@ const rdsBulkMerge = async function (callContext, connection, rdsMergeConfig) {
     }
     for (let i = 0; i < firstRow.length; i++) {
         let field = firstRow[i];
-        setsFields.push(getColumnNameByAlias(rdsTable, field.columnAlias))        
-        columns.push(rdsTable.columns.find(p=> p.alias === field.columnAlias))        
+        setsFields.push(getColumnNameByAlias(rdsTable, field.columnAlias))
+        columns.push(rdsTable.columns.find(p => p.alias === field.columnAlias))
     }
     for (let i = 0; i < rdsMergeConfig.sets.length; i++) {
         let set = rdsMergeConfig.sets[i];
         let row = [];
-        for (let j = 0; j < set.length; j++) {              
+        for (let j = 0; j < set.length; j++) {
             BlzRdsHelper.getSql(set[j].value, connection.provider.syntaxis, row)
         }
         values.push(row);
@@ -494,7 +494,7 @@ const rdsBulkMerge = async function (callContext, connection, rdsMergeConfig) {
         throw err;
     }
     const mergeFields = []
-    for(const field of rdsMergeConfig.fields) {
+    for (const field of rdsMergeConfig.fields) {
         if (!field || !field.columnRef || !field.columnRef.codePath) {
             let err = new Error();
             err.code = 'RdsError';
@@ -509,8 +509,8 @@ const rdsBulkMerge = async function (callContext, connection, rdsMergeConfig) {
             err.message = 'Merge sentence does not have merge fields defined.';
             throw err;
         }
-        if( !rdsTable.uniqueKeys || rdsTable.uniqueKeys.length === 0 || rdsTable.uniqueKeys.filter(p =>   p.columnsNames !== undefined && p.columnsNames.find(c => c === column.name)).length === 0 ) {
-            if (rdsTable.columns.filter(p => p.primaryKey && p.name === column.name).length === 0) { 
+        if (!rdsTable.uniqueKeys || rdsTable.uniqueKeys.length === 0 || rdsTable.uniqueKeys.filter(p => p.columnsNames !== undefined && p.columnsNames.find(c => c === column.name)).length === 0) {
+            if (rdsTable.columns.filter(p => p.primaryKey && p.name === column.name).length === 0) {
                 let err = new Error();
                 err.code = 'RdsError';
                 err.message = 'The field selected to determine the merge must be defined as unique key or primary key';
@@ -519,7 +519,7 @@ const rdsBulkMerge = async function (callContext, connection, rdsMergeConfig) {
         }
     }
     const sql = '';
-    let result = await BlzRdsExecutor.execute(callContext, connection, sql, values, { bulkMerge:true, mergeFields:mergeFields, autoincrementalData: autoincrementalData, columns , setsFields, rdsTable });
+    let result = await BlzRdsExecutor.execute(callContext, connection, sql, values, { bulkMerge: true, mergeFields: mergeFields, autoincrementalData: autoincrementalData, columns, setsFields, rdsTable });
     return result.affectedRows
 };
 
@@ -580,7 +580,7 @@ const rdsUpdate = async function (callContext, connection, rdsUpdateConfig) {
         let columnInfo = null;
         if (rdsUpdateConfig.sets[i])
             columnInfo = await findByAlias(connection.rdsElements[rdsUpdateConfig.rdsTableName].columns, rdsUpdateConfig.sets[i].columnAlias);
-        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in', columnInfo: columnInfo  });
+        parameters.push({ name: 'PARAM' + i, value: value, direction: 'in', columnInfo: columnInfo });
     }
     let result = await BlzRdsExecutor.execute(callContext, connection, sql, parameters, null);
     return result.rowsAffected;
@@ -607,7 +607,7 @@ const rdsUpdateWriter = function (connection, rdsUpdateWriterConfig) {
                 if (pkAliases.indexOf(key) === -1)
                     rdsUpdateConfig.sets.push({ columnAlias: key, value: { command: 'parameter', parameterValue: value } });
                 else
-                    whereChildren.push({ command: 'equals', children: [{ command: 'columnRef', columnRef: { codePath: key, embeddedIndex: 0 }}, { command: 'parameter', parameterValue: value }] });
+                    whereChildren.push({ command: 'equals', children: [{ command: 'columnRef', columnRef: { codePath: key, embeddedIndex: 0 } }, { command: 'parameter', parameterValue: value }] });
             }
             if (whereChildren.length > 0)
                 rdsUpdateConfig.where = { command: 'and', children: whereChildren };
@@ -704,8 +704,8 @@ const rdsConnectionHealthCheck = async function (connection, callContext) {
             sql = 'SELECT SYSDATE FROM DUAL'
             break;
         }
-        default:{
-            return { error: "Provider not yet implemented"}
+        default: {
+            return { error: "Provider not yet implemented" }
         }
     }
     // If this sql query was able to return a date, connection works
@@ -715,30 +715,32 @@ const rdsConnectionHealthCheck = async function (connection, callContext) {
             return { status: "ok", message: `Connection works, server datetime: ${JSON.stringify(result.data)}` }
         } else {
             return { status: "error", error: `Unable to obtain date from database ${JSON.stringify(result)}` }
-        } 
+        }
     } catch (error) {
         return { status: "error", error: JSON.stringify(error) }
     }
 };
 
 module.exports = {
-    rdsSelect,
-    rdsSelectReader,
-    rdsSelectOne,
-    rdsSelectOneReader,
-    rdsExists,
-    rdsInsert,
-    rdsInsertConditional,
-    rdsBulkInsert,
-    rdsBulkMerge,
-    rdsInsertWriter,
-    rdsUpdate,
-    rdsUpdateWriter,
-    rdsDelete,
-    rdsExecuteStoredProcedure,
-    rdsExecuteQuery,
-    rdsExecuteNonQuery,
-    rdsConnectionHealthCheck,
-    rdsEscape,
-    rdsEscapeId
+    Backend: {
+        rdsSelect,
+        rdsSelectReader,
+        rdsSelectOne,
+        rdsSelectOneReader,
+        rdsExists,
+        rdsInsert,
+        rdsInsertConditional,
+        rdsBulkInsert,
+        rdsBulkMerge,
+        rdsInsertWriter,
+        rdsUpdate,
+        rdsUpdateWriter,
+        rdsDelete,
+        rdsExecuteStoredProcedure,
+        rdsExecuteQuery,
+        rdsExecuteNonQuery,
+        rdsConnectionHealthCheck,
+        rdsEscape,
+        rdsEscapeId
+    }
 }

package/blz-rds-mysql/index.js

@@ -1,5 +1,5 @@
 const _ = require("underscore");
-const {executeNonQuery } = require("./execute-non-query");
+const { executeNonQuery } = require("./execute-non-query");
 const executeQuery = require("./execute-query");
 const executeBulkInsert = require("./execute-bulk-insert");
 const executeBulkMerge = require("./execute-bulk-merge");
@@ -18,24 +18,26 @@ process.on('exit', async function () {
 });
 
 module.exports = {
-    syntaxis: require("./syntaxis.json"),    
-    executeProcedure,    
-    executeSql: async function (connection, sql, parameters, options = {}) {
-        if(sql.indexOf("call") != -1 ) {
-            return await executeProcedure(connection, sql, parameters);
-        } else if(_.has(options, "bulkInsert")) {
-            return await executeBulkInsert(connection, sql, parameters, options);
-        } else if(_.has(options, "bulkMerge")) {
-            return await executeBulkMerge(connection, sql, parameters, options);        
-        } else if(_.has(options, "queryOne") || _.has(options, "query")) {
-            return await executeQuery(connection, sql, parameters, options);
-        } else {
-            return await executeNonQuery(connection, sql, parameters, options);
-        }
-    },
-    beginTransaction,    
-    close,
-    createRdsConnection,
-    commitTransaction,
-    rollbackTransaction,
+    Backend: {
+        syntaxis: require("./syntaxis.json"),
+        executeProcedure,
+        executeSql: async function (connection, sql, parameters, options = {}) {
+            if (sql.indexOf("call") != -1) {
+                return await executeProcedure(connection, sql, parameters);
+            } else if (_.has(options, "bulkInsert")) {
+                return await executeBulkInsert(connection, sql, parameters, options);
+            } else if (_.has(options, "bulkMerge")) {
+                return await executeBulkMerge(connection, sql, parameters, options);
+            } else if (_.has(options, "queryOne") || _.has(options, "query")) {
+                return await executeQuery(connection, sql, parameters, options);
+            } else {
+                return await executeNonQuery(connection, sql, parameters, options);
+            }
+        },
+        beginTransaction,
+        close,
+        createRdsConnection,
+        commitTransaction,
+        rollbackTransaction,
+    }
 }