db-crud-api 0.3.15 → 0.3.19

package/CHANGELOG.md

@@ -61,4 +61,8 @@
 
     Added:
         - config
-        - log via callback        
+        - log via callback        
+## v0.3.18 (2025-12-12)
+
+    Added:
+        - sessionStore

package/README.md

@@ -1,100 +1,100 @@
-# db-crud-api 💡
-    CRUD api for database tables.
-
-## Installation
-    npm install db-crud-api
-
-# Usage
-```javascript
-    import dbCrudApi from "db-crud-api";
-    const apiFactory = dbCrudApi(mySchema);
-
-    const mySchema = {
-        servers: {
-            server1: {
-                realName: "server1.mydomain.com",
-                type: "ms-sql",
-                instance: "DEFAULT",
-                user: "User1",
-                password: "mypassword",
-                options: {
-                    appName: "myAppName",
-                    ...
-                },
-                databases: {
-                    db1: {
-                        realName: "db_orders",
-                        tables: {
-                            table1: {
-                                realName: "tb_orders_head",
-                                idField: "Id",
-                                autoId: true,
-                                fields: {
-                                    Id: { realName: "OrderId", type: "uuid", lengh: undefined, canBeNull: false, description: "Unique Id", defaultValue: undefined },
-                                    CustomerId: { type: "string", lengh: undefined, canBeNull: false, description: "Customer Id", defaultValue: undefined },
-                                    ...
-                                }
-                            },
-                            table2: {
-                                realName: "tb_orders_detail",
-                                idField: "Id",
-                                autoId: true,
-                                fields: {
-                                    Id: { realName: "OrderId", type: "uuid", lengh: undefined, canBeNull: false, description: "Unique Id", defaultValue: undefined },
-                                    OrderId: { type: "uuid", lengh: undefined, canBeNull: false, description: "Order Id", defaultValue: undefined },
-                                    RowSeq: { type: "numeric", lengh: undefined, canBeNull: false, description: "Row sequence", defaultValue: undefined },
-                                    ...
-                                }
-                            },
-                            ...
-                        }
-                    },
-                    ...
-                }
-            },
-            ...
-        }
-    };
-
-    const apiOrder = apiFactory.newROApi("server1.db1.table1");  // Read Only api
-    const apiOrderDetail = apiFactory.newFullApi("table2"); // full CRUD api
-    const apiExecuteSP = apiFactory.newExecuteApi("db1.my_storeproc"); // execute my_storeproc
-
-    console.log(await apiFactory.testConnection()); // optional
-
-    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({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 apiExecuteSP.execute());   // execute procedure with no argument
-    console.log(await apiExecuteSP.execute({execute: {arguments: "@Company, @OrderNumber", params: {Company: "XXX", OrderNumber: "12345"}}}));   // execute procedure with arguments and params 
-```
-
-License
--------
-
-    MIT License
-
-    Copyright (c) 2022
-
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# db-crud-api 💡
+    CRUD api for database tables.
+
+## Installation
+    npm install db-crud-api
+
+# Usage
+```javascript
+    import dbCrudApi from "db-crud-api";
+    const apiFactory = dbCrudApi(mySchema);
+
+    const mySchema = {
+        servers: {
+            server1: {
+                realName: "server1.mydomain.com",
+                type: "ms-sql",
+                instance: "DEFAULT",
+                user: "User1",
+                password: "mypassword",
+                options: {
+                    appName: "myAppName",
+                    ...
+                },
+                databases: {
+                    db1: {
+                        realName: "db_orders",
+                        tables: {
+                            table1: {
+                                realName: "tb_orders_head",
+                                idField: "Id",
+                                autoId: true,
+                                fields: {
+                                    Id: { realName: "OrderId", type: "uuid", lengh: undefined, canBeNull: false, description: "Unique Id", defaultValue: undefined },
+                                    CustomerId: { type: "string", lengh: undefined, canBeNull: false, description: "Customer Id", defaultValue: undefined },
+                                    ...
+                                }
+                            },
+                            table2: {
+                                realName: "tb_orders_detail",
+                                idField: "Id",
+                                autoId: true,
+                                fields: {
+                                    Id: { realName: "OrderId", type: "uuid", lengh: undefined, canBeNull: false, description: "Unique Id", defaultValue: undefined },
+                                    OrderId: { type: "uuid", lengh: undefined, canBeNull: false, description: "Order Id", defaultValue: undefined },
+                                    RowSeq: { type: "numeric", lengh: undefined, canBeNull: false, description: "Row sequence", defaultValue: undefined },
+                                    ...
+                                }
+                            },
+                            ...
+                        }
+                    },
+                    ...
+                }
+            },
+            ...
+        }
+    };
+
+    const apiOrder = apiFactory.newROApi("server1.db1.table1");  // Read Only api
+    const apiOrderDetail = apiFactory.newFullApi("table2"); // full CRUD api
+    const apiExecuteSP = apiFactory.newExecuteApi("db1.my_storeproc"); // execute my_storeproc
+
+    console.log(await apiFactory.testConnection()); // optional
+
+    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({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 apiExecuteSP.execute());   // execute procedure with no argument
+    console.log(await apiExecuteSP.execute({execute: {arguments: "@Company, @OrderNumber", params: {Company: "XXX", OrderNumber: "12345"}}}));   // execute procedure with arguments and params 
+```
+
+License
+-------
+
+    MIT License
+
+    Copyright (c) 2022
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     SOFTWARE.

package/index.js

@@ -5,16 +5,17 @@ import * as apiFactory from "./lib/api-factory.js";
 
 export default function(customSchema, config) {
     if (customSchema && customSchema.servers) {
-        schema.servers = customSchema.servers;
+        apiFactory.setSchemaServers(customSchema.servers);
     }
     if (config) {
         if (config.log) {
-            if (config.log.level) {
-                if (typeof(config.log.level) === 'number') { schema.config.log.level = config.log.level }
-                else if (typeof(config.log.level) === 'string' && Number.parseInt(config.log.level) != NaN) { schema.config.log.level = Number.parseInt(config.log.level) }
-            }
-            if (config.log.callback && typeof(config.log.callback) === 'function') { schema.config.log.callback = config.log.callback }
+            if (config.log.level) { apiFactory.setLogLevel(config.log.level) }
+            if (config.log.callback) { apiFactory.setLogCallback(config.log.callback) }
+            if (config.log.maxAsyncInstances) { apiFactory.setLogMaxAsyncInstances(config.log.maxAsyncInstances) }
+        }
+        if (config.session) {
+            if (config.session.tablePath) { apiFactory.setSessionTablePath(config.session.tablePath) }
         }
     }
     return apiFactory;
-}
+}

package/lib/api-factory.js

@@ -1,31 +1,60 @@
-"use strict";
-
-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);
-}
-
-export function newROApi(tablePath) {
-    return new apiRO(tablePath);
-}
-
-export function newExecuteApi(procPath) {
-    return new apiExecute(procPath);
-}
-
-export function newBatchApi(useTransaction) {
-    return new apiBatch(useTransaction);
-}
-
-export function closeAllDbConnections() {
-    return dbOpe.closeAllConnections();
-}
-
-export function testDbConnection() {
-    return dbOpe.testConnection();
+"use strict";
+
+import schema from "./schema.js";
+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"
+import sessionStore from "./api-session-store.js"
+
+
+export function newFullApi(tablePath) {
+    return new apiFull(tablePath);
+}
+
+export function newROApi(tablePath) {
+    return new apiRO(tablePath);
+}
+
+export function newExecuteApi(procPath) {
+    return new apiExecute(procPath);
+}
+
+export function newBatchApi(useTransaction) {
+    return new apiBatch(useTransaction);
+}
+
+export function closeAllDbConnections() {
+    return dbOpe.closeAllConnections();
+}
+
+export function newSessionStore(options) {
+    return new sessionStore(options);
+}
+
+export function testDbConnection() {
+    return dbOpe.testConnection();
+}
+
+export function setLogLevel(level) {
+    if (typeof level === 'number') { schema.config.log.level = level } 
+    else if (typeof level === 'string' && Number.parseInt(level) != NaN) { schema.config.log.level = Number.parseInt(level) }
+}
+
+export function setLogCallback(callback) {
+    if (typeof callback === 'function') { schema.config.log.callback = callback }
+}
+
+export function setLogMaxAsyncInstances(maxAsyncInstances) {
+    if (typeof maxAsyncInstances === 'number') { schema.config.log.maxAsyncInstance = maxAsyncInstances } 
+    else if (typeof maxAsyncInstances === 'string' && Number.parseInt(maxAsyncInstances) != NaN) { schema.config.log.maxAsyncInstance = Number.parseInt(maxAsyncInstances) }
+}
+
+export function setSessionTablePath(tablePath) {
+    if (typeof tablePath === 'string' && tablePath.length > 0) { schema.config.session.tablePath = tablePath }  
+}
+
+export function setSchemaServers(servers) {
+    schema.servers = servers;
 }

package/lib/api-full.js

@@ -1,96 +1,105 @@
-'use strict';
-
-// Import modules
-import { v4 as uuidv4 } from 'uuid';
-import * as dbOpe from './db-operations.js';
-
-export default class apiFull {
-
-    #schema;
-    #connection;
-
-    constructor(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; }
-
-    // Get by id
-    async getById(id, reqOpe) {
-        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, this.#connection, reqOpe);
-        return await dbOpe.runQuery(_dbOpe);
-    }
-
-    // Post by id (any operation like get/put/patch/delete...)
-    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, this.#connection, reqOpe);
-        return await dbOpe.runQuery(_dbOpe);
-    }
-
-    // Add item
-    async put(reqOpe) {
-        const _dbOpe = dbOpe.preparePut(this.#schema, this.#connection, reqOpe);
-        if (_dbOpe.put.sets) {
-            if (dbOpe.autoId(this.#schema))  // 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(_dbOpe);
-        return _dbOpe.put.sets;
-    }
-
-    // Add by Id
-    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)]);
-        return _return;
-    }    
-
-    // Delete by id
-    async delById(id) {
-        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, this.#connection, reqOpe);
-        return await dbOpe.runQuery(_dbOpe);
-    }
-
-    // Patch (update) by id
-    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, this.#connection, reqOpe);
-        return await dbOpe.runQuery(_dbOpe);
-    }
-
+'use strict';
+
+// Import modules
+import { v4 as uuidv4 } from 'uuid';
+import * as dbOpe from './db-operations.js';
+
+export default class apiFull {
+
+    #schema;
+    #connection;
+
+    constructor(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; }
+
+    // Get by id
+    async getById(id, reqOpe) {
+        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, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
+    }
+
+    // Post by id (any operation like get/put/patch/delete...)
+    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, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
+    }
+
+    // Add item
+    async put(reqOpe) {
+        const _dbOpe = dbOpe.preparePut(this.#schema, this.#connection, reqOpe);
+        if (_dbOpe.put.sets) {
+            if (dbOpe.autoId(this.#schema))  // 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(_dbOpe);
+        return _dbOpe.put.sets;
+    }
+
+    // Add or update item by Id
+    async putById(reqOpe, id) {
+        const _old = await this.getById(id, { get: { fields: [dbOpe.idField(this.#schema)] } });
+        if (!_old) {
+            const _dbOpePut = dbOpe.preparePutById(this.#schema, this.#connection, reqOpe, id);
+            await dbOpe.runQuery(_dbOpePut);
+            return _dbOpePut.put.sets;
+        }
+        else {
+            const _patchOpe = { patch: {sets: reqOpe.put.sets} };
+            await this.patchById(_patchOpe, id);
+            return _patchOpe.patch.sets;
+        }
+    }
+
+    // New (put + getById)
+    async new(reqOpe) {
+        const obj = await this.put(reqOpe);
+        //const _return = await this.getById(obj[dbOpe.idField(this.#schema)]);
+        const _return = await this.getById(dbOpe.getProperty(obj, dbOpe.idField(this.#schema)));
+        return _return;
+    }    
+
+    // Delete by id
+    async delById(id) {
+        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, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
+    }
+
+    // Patch (update) by id
+    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, this.#connection, reqOpe);
+        return await dbOpe.runQuery(_dbOpe);
+    }
+
 }