db-crud-api 0.1.9 → 0.2.1

package/CHANGELOG.md

@@ -22,3 +22,16 @@
 
     Bug fix:
         - update function crash with date value
+## v0.1.9 (2024-03-12)
+
+    Added:
+        - execute store procedure
+## v0.2.0 (2024-04-02)
+
+    Changes:
+        - parameters position have been change for some api 
+    Added:
+        - batch job that run multiple instructions
+## v0.2.1 (2024-12-05)
+
+    Refresh dependency

package/README.md

@@ -61,13 +61,13 @@
     const apiExecuteSP = apiFactory.newExecuteApi("my_storeproc @Company, @OrderNumber"); // execute my_storeproc
 
     console.log(await apiOrder.getById("xxxxx-xxxxx-xxxxxxxxxxxx-xxxxxx"));
+    console.log(await apiOrder.getById("xxxxx-xxxxx-xxxxxxxxxxxx-xxxxxx", {get: {fields: ["Id", "OrderNumber", "OrderTotal"]}}));
     console.log(await apiOrder.getByFilter({get: {filters: ["OrderType in ('P', 'A')", "and", "OrderDate > '2022-12-01'"]}}));   // get filterd rows
     console.log(await apiOrder.getByFilter());   // this get all rows
-    console.log(await apiOrderDetail.patchById("xxxxx-xxxxx-xxxxxxxxxxxx-xxxxxx", {patch: {sets: {ItemRef: "2024-TX-0001", ItemDate: "2024-01-31"}}}));   // change some fields
+    console.log(await apiOrderDetail.patchById({patch: {sets: {ItemRef: "2024-TX-0001", ItemDate: "2024-01-31"}}}, "xxxxx-xxxxx-xxxxxxxxxxxx-xxxxxx"));   // change some fields
     console.log(await apiOrderDetail.patchByFilter({patch: {sets: {LastUpdate: "2023-04-30"}, filters: ["OrderId: 'xxxxx-xxxxx-xxxxxxxxxxxx-xxxxxx'"]}}));   // change by filter
     console.log(await apiOrderDetail.deleteById("xxxxx-xxxxx-xxxxxxxxxxxx-xxxxxx"));   // delete row by Id
     console.log(await apiOrderDetail.deleteByFilter({delete: {filters: ["ItemType in ('X', 'W')", "and", "ItemDate > '2022-12-01'"]}}));   // delete filterd rows
-    console.log(await apiOrderDetail.deleteByFilter({delete: {filters: ["ItemType in ('X', 'W')", "and", "ItemDate > '2022-12-01'"]}}));   // delete filterd rows
     console.log(await apiExecuteSP.execute({params: {Company: "XXX", OrderNumber: "12345"}}}));   // execute 
 ```
 

package/lib/api-batch.js

@@ -0,0 +1,139 @@
+'use strict';
+
+// Import modules
+import { v4 as uuidv4 } from 'uuid';
+import * as dbOpe from './db-operations.js';
+
+export default class apiBatch {
+
+    #operations = [];
+    #dbOperations = [];
+    #useTransaction = false;
+
+    constructor(useTransaction) {
+        if (typeof(useTransaction) === "boolean") this.#useTransaction = useTransaction;
+    }
+
+    get useTransaction() { return this.#useTransaction; }
+    set useTransaction(useTransaction) { if (typeof(useTransaction) === "boolean") this.#useTransaction = useTransaction; }
+
+    // reset Batch
+    #resetBatch() {
+        this.#operations = [];
+        this.#dbOperations = [];
+    }
+
+    // run batch
+    async runBatch() {
+
+        if (this.#dbOperations.length == 0) { throw new Error("runBatch: there are not operations in this batch.") }
+
+        // prepare transaction
+        if (this.#useTransaction) {
+            const _reqOpe_begin = {begin: {}};
+            const _dbOpe_begin = dbOpe.prepareBegin(this.#dbOperations[0].connection, _reqOpe_begin);
+            this.#dbOperations.unshift(_dbOpe_begin);    
+            this.#operations.unshift(_reqOpe_begin);    
+
+            const _reqOpe_commit = {commit: {}};
+            const _dbOpe_commit = dbOpe.prepareCommit(this.#dbOperations[0].connection, _reqOpe_commit);
+            this.#dbOperations.push(_dbOpe_commit);    
+            this.#operations.push(_reqOpe_commit);    
+        }
+
+        // run
+        const _return = await dbOpe.runQuery(this.#dbOperations);
+
+        // reset
+        this.#resetBatch();
+
+        return _return;
+    }
+
+    // execute 
+    execute(command, reqOpe) {
+        const _schema = dbOpe.prepareSchema(command, dbOpe.objectType.procedure);
+        const _connection = dbOpe.prepareConnection(_schema);
+        this.#dbOperations.push(dbOpe.prepareExecute(_schema, _connection, reqOpe));
+        this.#operations.push(reqOpe);
+        return;
+    }
+
+    // Get by id
+    // note that getById when executed in a batch, return an array instead of single object
+    getById(tablePath, id, reqOpe) {
+        const _schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
+        const _connection = dbOpe.prepareConnection(_schema);
+        this.#dbOperations.push(dbOpe.prepareGetById(_schema, _connection, reqOpe, id));
+        this.#operations.push(reqOpe);        
+        return;
+    }
+
+    // Get by filter
+    getByFilter(tablePath, reqOpe) {
+        const _schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
+        const _connection = dbOpe.prepareConnection(_schema);
+        this.#dbOperations.push(dbOpe.prepareGet(_schema, _connection, reqOpe));
+        this.#operations.push(reqOpe);        
+        return;
+    }
+
+    // Add
+    put(tablePath, reqOpe) {
+        const _schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
+        const _connection = dbOpe.prepareConnection(_schema);
+        const _dbOpe =  dbOpe.preparePut(_schema, _connection, reqOpe);
+        if (_dbOpe.put.sets && _schema.autoId === true)  // automatic Id
+            if (!Object.keys(_dbOpe.put.sets).find(key => key.toUpperCase() === (dbOpe.idField(_schema)).toUpperCase()))
+                _dbOpe.put.sets[dbOpe.idField(_schema)] = uuidv4();  // automatic Id via uuidv4
+        this.#dbOperations.push(_dbOpe);
+        this.#operations.push(reqOpe);        
+        return;
+    }
+
+    // Add by Id
+    putById(tablePath, reqOpe, id) {
+        const _schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
+        const _connection = dbOpe.prepareConnection(_schema);
+        this.#dbOperations.push(dbOpe.preparePutById(_schema, _connection, reqOpe, id));
+        this.#operations.push(reqOpe);        
+        return;
+    }
+
+    // Delete by id
+    delById(tablePath, id) {
+        const _schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
+        const _connection = dbOpe.prepareConnection(_schema);
+        this.#dbOperations.push(dbOpe.prepareDeleteById(_schema, _connection, id));
+        this.#operations.push({});        
+        return;
+    }
+
+    // Delete by filters
+    delByFilter(tablePath, reqOpe) {
+        const _schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
+        const _connection = dbOpe.prepareConnection(_schema);
+        this.#dbOperations.push(dbOpe.prepareDelete(_schema, _connection, reqOpe));
+        this.#operations.push(reqOpe);        
+        return;
+    }
+
+    // Patch (update) by id
+    patchById(tablePath, reqOpe, id) {
+        const _schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
+        const _connection = dbOpe.prepareConnection(_schema);
+        this.#dbOperations.push(dbOpe.preparePatchById(_schema, _connection, reqOpe, id));
+        this.#operations.push(reqOpe);        
+        return;
+    }
+
+    // Patch (update) by filters
+    patchByFilter(tablePath, reqOpe) {
+        const _schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
+        const _connection = dbOpe.prepareConnection(_schema);
+        this.#dbOperations.push(dbOpe.preparePatch(_schema, _connection, reqOpe));
+        this.#operations.push(reqOpe);        
+        return;
+    }
+
+}

package/lib/api-execute.js

@@ -9,17 +9,17 @@ export default class apiExecute {
     #connection;
 
     constructor(command) {
-        this.#schema = dbOpe.prepareSchema(command, "SP");
+        this.#schema = dbOpe.prepareSchema(command, dbOpe.objectType.procedure);
         this.#connection = dbOpe.prepareConnection(this.#schema);
     }
 
     get schema() { return this.#schema; }
     get connection() { return this.#connection; }
 
-    // Post (any operation like get/put/patch/delete...)
+    // execute
     async execute(reqOpe) {
-        const _dbOpe = dbOpe.prepareExecute(this.#schema, reqOpe);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.prepareExecute(this.#schema, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
 }

package/lib/api-factory.js

@@ -4,6 +4,7 @@ import * as dbOpe from "./db-operations.js"
 import apiFull from "./api-full.js"
 import apiRO from "./api-ro.js"
 import apiExecute from "./api-execute.js"
+import apiBatch from "./api-batch.js"
 
 export function newFullApi(tablePath) {
     return new apiFull(tablePath);
@@ -17,6 +18,10 @@ export function newExecuteApi(command) {
     return new apiExecute(command);
 }
 
+export function newBatchApi(useTransaction) {
+    return new apiBatch(useTransaction);
+}
+
 export function closeAllDbConnections() {
     return dbOpe.closeAllConnections();
 }

package/lib/api-full.js

@@ -10,93 +10,87 @@ export default class apiFull {
     #connection;
 
     constructor(tablePath) {
-        this.#schema = dbOpe.prepareTableSchema(tablePath);
+        this.#schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
         this.#connection = dbOpe.prepareConnection(this.#schema);
     }
 
     get schema() { return this.#schema; }
     get connection() { return this.#connection; }
 
-    // Run query
-//    async runOpe(_dbOpe) {
-//        return await dbOpe.runQuery(this.#connection, _dbOpe);
-//    }
-
     // Get by id
     async getById(id, reqOpe) {
-        const _dbOpe = dbOpe.prepareGetById(this.#schema, id, reqOpe);
-        const result = await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.prepareGetById(this.#schema, this.#connection, reqOpe, id);
+        const result = await dbOpe.runQuery(_dbOpe);
         return Array.isArray(result) ? result[0] : result;
-        
     }
 
     // Get by filter
     async getByFilter(reqOpe) {
-        const _dbOpe = dbOpe.prepareGet(this.#schema, reqOpe);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.prepareGet(this.#schema, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
     // Post by id (any operation like get/put/patch/delete...)
-    async postById(id, reqOpe) {
-        const _dbOpe = dbOpe.prepareRunById(this.#schema, id, reqOpe);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+    async postById(reqOpe, id) {
+        const _dbOpe = dbOpe.prepareRunById(this.#schema, this.#connection, reqOpe, id);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
     // Post (any operation like get/put/patch/delete...)
     async post(reqOpe) {
-        const _dbOpe = dbOpe.prepareRun(this.#schema, reqOpe);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.prepareRun(this.#schema, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
     // Add item
     async put(reqOpe) {
-        const _dbOpe = dbOpe.preparePut(this.#schema, reqOpe);
+        const _dbOpe = dbOpe.preparePut(this.#schema, this.#connection, reqOpe);
         if (_dbOpe.put.sets) {
             if (this.#schema.autoId === true)  // automatic Id
                 if (!Object.keys(_dbOpe.put.sets).find(key => key.toUpperCase() === (dbOpe.idField(this.#schema)).toUpperCase())) {
                     _dbOpe.put.sets[dbOpe.idField(this.#schema)] = uuidv4();  // automatic Id via uuidv4
                 }
         }
-        await dbOpe.runQuery(this.#connection, _dbOpe);
+        await dbOpe.runQuery(_dbOpe);
         return _dbOpe.put.sets;
     }
 
     // Add by Id
-    async putById(id, reqOpe) {
-        const _dbOpe = dbOpe.preparePutById(this.#schema, id, reqOpe);
-        await dbOpe.runQuery(this.#connection, _dbOpe);
+    async putById(reqOpe, id) {
+        const _dbOpe = dbOpe.preparePutById(this.#schema, this.#connection, reqOpe, id);
+        await dbOpe.runQuery(_dbOpe);
         return _dbOpe.put.sets;
     }
 
     // New (put + getById)
     async new(reqOpe) {
         const obj = await this.put(reqOpe);
-        const _return = await this.getById(obj[dbOpe.idField(this.#schema)], undefined);
+        const _return = await this.getById(obj[dbOpe.idField(this.#schema)]);
         return _return;
     }    
 
     // Delete by id
     async delById(id) {
-        const _dbOpe = dbOpe.prepareDeleteById(this.#schema, id);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.prepareDeleteById(this.#schema, this.#connection, id);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
     // Delete by filters
     async delByFilter(reqOpe) {
-        const _dbOpe = dbOpe.prepareDelete(this.#schema, reqOpe);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.prepareDelete(this.#schema, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
     // Patch (update) by id
-    async patchById(id, reqOpe) {
-        const _dbOpe = dbOpe.preparePatchById(this.#schema, id, reqOpe);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+    async patchById(reqOpe, id) {
+        const _dbOpe = dbOpe.preparePatchById(this.#schema, this.#connection, reqOpe, id);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
     // Patch (update) by filters
     async patchByFilter(reqOpe) {
-        const _dbOpe = dbOpe.preparePatch(this.#schema, reqOpe);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.preparePatch(this.#schema, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
 }

package/lib/api-ro.js

@@ -9,7 +9,7 @@ export default class apiRO {
     #connection;
 
     constructor(tablePath) {
-        this.#schema = dbOpe.prepareTableSchema(tablePath);
+        this.#schema = dbOpe.prepareSchema(tablePath, dbOpe.objectType.table);
         this.#connection = dbOpe.prepareConnection(this.#schema);
     }
 
@@ -23,16 +23,16 @@ export default class apiRO {
 
     // Get by id
     async getById(id, reqOpe) {
-        const _dbOpe = dbOpe.prepareGetById(this.#schema, id, reqOpe);
-        const result = await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.prepareGetById(this.#schema, this.#connection, reqOpe, id);
+        const result = await dbOpe.runQuery(_dbOpe);
         return Array.isArray(result) ? result[0] : result;
         
     }
 
     // Get by filter
     async getByFilter(reqOpe) {
-        const _dbOpe = dbOpe.prepareGet(this.#schema, reqOpe);
-        return await dbOpe.runQuery(this.#connection, _dbOpe);
+        const _dbOpe = dbOpe.prepareGet(this.#schema, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
     }
 
 }

package/lib/db-operations.js

@@ -6,35 +6,49 @@ import * as mssql from './mssql.js';
 
 // Common
 const defautlFields = ['*'];
-const c_ServerType_mssql = "ms-sql";
+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(connection, dbOpes) {
-    if (connection.serverType === c_ServerType_mssql) {
-        const sqlresult = await mssql.query(connection, dbOpes);
+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; }
+        if (sqlresult.recordsets.length === 0) return;
+        if (sqlresult.recordsets.length === 1) return sqlresult.recordsets[0];
+        else return sqlresult.recordsets;
     }
-    throw new TypeError('server type not supported');
+
+    // server type not supported
+    else throw new TypeError('server type not supported');
+    
 }
 
-export function prepareConnection(tSchema) {
-    if (!tSchema.server.type || tSchema.server.type === c_ServerType_mssql) {  // mssql is also the default
-        let _return = mssql.prepareConnection(tSchema);
-        _return.serverType = c_ServerType_mssql;  // append 'serverType' to connection
+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 === c_ServerType_mssql) { return mssql.closeConnection(connection); }
+    if (connection.serverType === serverType.mssql) { return mssql.closeConnection(connection); }
 }
 
 export function closeAllConnections() {
@@ -49,11 +63,11 @@ export function toStringValue(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.speName @param1' or 'spName' or 'systemNme..spName'
-    // objType = "T" or "SP"  (Table or StoreProcedure)
+    //     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 !== 'T' && objType !== 'SP') throw new TypeError('prepareSchema: wrong objType, must be "T" or "SP"');
+    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
@@ -97,7 +111,7 @@ export function prepareSchema(obj, objType) {
     if (!schema.servers[serverName].databases[dbName].realName) { schema.servers[serverName].databases[dbName].realName = dbName } // add realName
 
     // table
-    if (objType === "T" || objType == undefined) {
+    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];
@@ -110,7 +124,7 @@ export function prepareSchema(obj, objType) {
     }
 
     // store procedure
-    if (objType === "SP") {
+    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];
@@ -122,36 +136,36 @@ export function prepareSchema(obj, objType) {
         if (!schema.servers[serverName].databases[dbName].procedures[objName].realName) { schema.servers[serverName].databases[dbName].procedures[objName].realName = objName } // add realName
     }
 
-    // return tSchema
+    // return Schema
     return {
-        table: (objType == undefined || objType === 'T') ? schema.servers[serverName].databases[dbName].tables[objName] : undefined,
-        procedure:  (objType === 'SP') ? schema.servers[serverName].databases[dbName].procedures[objName] : undefined,
+        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) {
+//export function prepareTableSchema(tablePath) {
     // alias for prepareSchema (will be removed soon)
-    return prepareSchema(tablePath, "T")
-}
+//    return prepareSchema(tablePath, objectType.table)
+//}
 
-export function prepareRun(tSchema, reqOpe) {
-    let _reqOpe = [];
-    let _result = [];
+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, _ope));
-        else if (_ope?.patch) _result.push(preparePatch(tSchema, _ope));
-        else if (_ope?.put) _result.push(preparePut(tSchema, _ope));
-        else if (_ope?.delete) _result.push(prepareDelete(tSchema, _ope));
-        else if (_ope?.execute) _result.push(prepareExecute(_ope));
-        else if (_ope?.begin) _result.push(prepareBegin(_ope));
-        else if (_ope?.commit) _result.push(prepareCommit(_ope));
-        else if (_ope?.rollback) _result.push(prepareRollback(_ope));
-        else if (_ope?.passthrough) _result.push(preparePassthrough(_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;
@@ -159,17 +173,17 @@ export function prepareRun(tSchema, reqOpe) {
     return undefined;
 }
 
-export function prepareRunById(tSchema, idValue, reqOpe) {
-    if (reqOpe?.get) return prepareGetById(tSchema, idValue, reqOpe);
-    if (reqOpe?.patch) return preparePatchById(tSchema, idValue, reqOpe);
-    if (reqOpe?.put) return preparePutById(tSchema, idValue, reqOpe);
-    if (reqOpe?.delete) return prepareDeleteById(tSchema, idValue, reqOpe);
+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, reqOpe) {
-    let _reqOpe = [];
-    let _result = [];
+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) {
@@ -184,7 +198,8 @@ export function prepareGet(tSchema, reqOpe) {
                 groupsFilters: _ope?.get?.groupsFilters,
                 orderBy: _ope?.get?.orderBy,
                 params: _ope?.get?.params
-            }
+            },
+            connection: connection
         });
     });
     if (_result.length > 1) return _result;
@@ -192,7 +207,7 @@ export function prepareGet(tSchema, reqOpe) {
     return undefined;
 };
 
-export function prepareGetById(tSchema, idValue, reqOpe) {
+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');
@@ -204,13 +219,14 @@ export function prepareGetById(tSchema, idValue, reqOpe) {
             options: reqOpe?.get?.options,
             fields: reqOpe?.get?.fields ?? defautlFields,
             filters: _filters
-        }
+        },
+        connection: connection
     }
 };
 
-export function preparePatch(tSchema, reqOpe) {
-    let _reqOpe = [];
-    let _result = [];
+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) {
@@ -222,7 +238,8 @@ export function preparePatch(tSchema, reqOpe) {
                     sets: _ope.patch.sets,
                     filters: _ope.patch.filters,
                     params: _ope?.patch.params
-                }
+                },
+                connection: connection
             });
         }
         else throw new Error('Request sintax error, missing "patch" property.');
@@ -232,10 +249,10 @@ export function preparePatch(tSchema, reqOpe) {
     return undefined;
 };
 
-export function preparePatchById(tSchema, idValue, reqOpe) {
+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.')
-    let _filters = [idField(tSchema) + ' = ' + toStringValue(idValue)];
+    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);
@@ -245,13 +262,14 @@ export function preparePatchById(tSchema, idValue, reqOpe) {
             schema: tSchema,
             sets: reqOpe.patch.sets,
             filters: _filters
-        }
+        },
+        connection: connection
     }
 };
 
-export function preparePut(tSchema, reqOpe) {
-    let _reqOpe = [];
-    let _result = [];
+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) {
@@ -262,7 +280,8 @@ export function preparePut(tSchema, reqOpe) {
                     schema: tSchema,
                     sets: reqOpe.put.sets,
                     params: reqOpe?.put.params
-                }
+                },
+                connection: connection
             });
         }
         else throw new Error('Request sintax error, missing "put" property.');
@@ -272,7 +291,7 @@ export function preparePut(tSchema, reqOpe) {
     return undefined;
 };
 
-export function preparePutById(tSchema, idValue, reqOpe) {
+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;
@@ -281,13 +300,14 @@ export function preparePutById(tSchema, idValue, reqOpe) {
             schema: tSchema,
             sets: reqOpe.put.sets,
             params: reqOpe?.put?.params
-        }
+        },
+        connection: connection
     }
 };
 
-export function prepareDelete(tSchema, reqOpe) {
-    let _reqOpe = [];
-    let _result = [];
+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) {
@@ -298,7 +318,8 @@ export function prepareDelete(tSchema, reqOpe) {
                     schema: tSchema,
                     filters: _ope.delete.filters,
                     params: _ope.delete.params
-                }
+                },
+                connection: connection
             });
         }
         else throw new Error('Request sintax error, missing "delete" property.');
@@ -308,18 +329,19 @@ export function prepareDelete(tSchema, reqOpe) {
     return undefined;
 };
 
-export function prepareDeleteById(tSchema, idValue) {
+export function prepareDeleteById(tSchema, connection, idValue) {
     return {
         delete: {
             schema: tSchema,
             filters: [idField(tSchema) + ' = ' + toStringValue(idValue)]
-        }
+        },
+        connection: connection
     }
 };
 
-export function prepareExecute(pSchema, reqOpe) {
-    let _reqOpe = [];
-    let _result = [];
+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) {
@@ -328,7 +350,8 @@ export function prepareExecute(pSchema, reqOpe) {
                 schema: pSchema,
                 command: pSchema.command,
                 params: _ope.params
-            }
+            },
+            connection: connection
         });
     });
     if (_result.length > 1) return _result;
@@ -336,9 +359,9 @@ export function prepareExecute(pSchema, reqOpe) {
     return undefined;
 };
 
-export function preparePassthrough(reqOpe) {
-    let _reqOpe = [];
-    let _result = [];
+export function preparePassthrough(connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
     if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
     else _reqOpe.push(reqOpe);
     _reqOpe.forEach(function (_ope) {
@@ -348,7 +371,8 @@ export function preparePassthrough(reqOpe) {
                 passthrough: {
                     command: _ope.passthrough.command,
                     params: _ope.passthrough.params
-                }
+                },
+                connection: connection
             });
         }
         else throw new Error('Request sintax error, missing "passthrough" property.');
@@ -358,20 +382,23 @@ export function preparePassthrough(reqOpe) {
     return undefined;
 };
 
-export function prepareBegin(reqOpe) {
+export function prepareBegin(connection, reqOpe) {
     return {
-        begin: {}
+        begin: {},
+        connection: connection
     }
 };
 
-export function prepareCommit(reqOpe) {
+export function prepareCommit(connection, reqOpe) {
     return {
-        commit: {}
+        commit: {},
+        connection: connection
     }
 };
 
-export function prepareRollback(reqOpe) {
+export function prepareRollback(connection, reqOpe) {
     return {
-        rollback: {}
+        rollback: {},
+        connection: connection
     }
 };

package/lib/mssql.js

@@ -79,11 +79,8 @@ export async function query(connection, dbOpes) {
     // Prepare sql statement
     let sqlString = '';
     let sqlRequest = pool.request();
-    if (Array.isArray(dbOpes))
-        dbOpes.forEach((dbOpe, index) => {
-            if (index > 0) sqlString += '; '
-            sqlString += ToSql(dbOpe, sqlRequest);  // if exists, input params will be added to request
-        });
+    // 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);
 
     // Run query
@@ -113,7 +110,6 @@ function ToSql(dbOpe, sqlRequest) {
     if (dbOpe.execute) return executeToSql(dbOpe, sqlRequest);
     if (dbOpe.begin) return beginToSql(dbOpe, sqlRequest);
     if (dbOpe.commit) return commitToSql(dbOpe, sqlRequest);
-    if (dbOpe.rollback) return rollbackToSql(dbOpe, sqlRequest);
     if (dbOpe.passthrough) return passthroughToSql(dbOpe, sqlRequest);
 }
 
@@ -173,6 +169,8 @@ function getToSql(dbOpe, sqlRequest) {
 
     if (dbOpe.get.params) addParams(dbOpe.get.params, sqlRequest);
 
+    result += ';' 
+
     return result;
 }
 
@@ -190,6 +188,8 @@ function patchToSql(dbOpe, sqlRequest) {
 
     if (dbOpe.patch.params) addParams(dbOpe.patch.params, sqlRequest);
 
+    result += ';' 
+
     return result;
 }
 
@@ -211,6 +211,8 @@ function putToSql(dbOpe, sqlRequest) {
 
     if (dbOpe.put.params) addParams(dbOpe.put.params, sqlRequest);
 
+    result += ';' 
+
     return result;
 }
 
@@ -225,6 +227,8 @@ function deleteToSql(dbOpe, sqlRequest) {
 
     if (dbOpe.delete.params) addParams(dbOpe.delete.params, sqlRequest);
 
+    result += ';' 
+
     return result;
 }
 
@@ -239,22 +243,27 @@ function executeToSql(dbOpe, sqlRequest) {
 
     if (dbOpe.execute.params) addParams(dbOpe.execute.params, sqlRequest);
 
+    result += ';' 
+
     return result;
 }
 
 // Parse begin operation object to sql string
 function beginToSql(dbOpe, sqlRequest) {
-    return "BEGIN TRANSACTION";
+    return "BEGIN TRY BEGIN TRANSACTION;";
 }
 
 // Parse commit operation object to sql string
 function commitToSql(dbOpe, sqlRequest) {
-    return "COMMIT";
-}
-
-// Parse rollback operation object to sql string
-function rollbackToSql(dbOpe, sqlRequest) {
-    return "ROLLBACK";
+    return "IF @@TRANCOUNT > 0 COMMIT TRANSACTION; \
+END TRY \
+BEGIN CATCH \
+IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION; \
+DECLARE @ErrorMessage NVARCHAR(4000); \
+DECLARE @ErrorSeverity INT; \
+DECLARE @ErrorState INT; \
+RAISERROR (@ErrorMessage, @ErrorSeverity, @ErrorState); \
+END CATCH";
 }
 
 // Add input parameters to pool.request

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "db-crud-api",
-  "version": "0.1.9",
+  "version": "0.2.1",
   "type": "module",
   "description": "CRUD api for database tables",
   "main": "index.js",
@@ -10,8 +10,8 @@
   "author": "FF",
   "license": "MIT",
   "dependencies": {
-    "mssql": "^9.3.2",
-    "uuid": "^9.0.1"
+    "mssql": "^11.0.1",
+    "uuid": "^11.0.3"
   },
   "keywords":["db","crud","api"]
 }