@nsshunt/stsdatamanagement 1.18.200 → 1.18.201

package/dist/pgaccesslayer-old.js

@@ -1,14 +1,14 @@
 /* eslint @typescript-eslint/no-explicit-any: 0 */ // --> OFF
-import { StatusCodes } from 'http-status-codes';
-import chalk from 'chalk';
+import { StatusCodes } from "http-status-codes";
+import chalk from "chalk";
 import { Redis } from "ioredis";
-import { goptions } from '@nsshunt/stsconfig';
-import pgcopystreams from 'pg-copy-streams';
+import { goptions } from "@nsshunt/stsconfig";
+import pgcopystreams from "pg-copy-streams";
 const copyFrom = pgcopystreams.from;
-import * as streamex from 'node:stream';
-import * as fs from 'node:fs/promises';
-const defaultConfigId = 'defaultconfig';
-const systemUserId = 'SystemUserID';
+import * as streamex from "node:stream";
+import * as fs from "node:fs/promises";
+const defaultConfigId = "defaultconfig";
+const systemUserId = "SystemUserID";
 export class PGAccessLayer {
     #options;
     #ioredisCache = null;
@@ -20,7 +20,7 @@ export class PGAccessLayer {
         if (useRedisDatabaseCache === true) {
             const redisOptions = {
                 showFriendlyErrorStack: true,
-                maxRetriesPerRequest: 20
+                maxRetriesPerRequest: 20,
             };
             this.#ioredisCache = new Redis(redisDatabaseCacheUrl, redisOptions);
         }
@@ -33,73 +33,80 @@ export class PGAccessLayer {
     }
     #latestResourceVersion(inputfilter) {
         // Check if we are getting the latest version
-        const { resname, entname, vnum, filter, incdel, startdate, enddate, dbaction, dbactionuser } = inputfilter;
-        return (resname !== undefined && entname === undefined && vnum === undefined && filter === undefined && incdel === undefined && startdate === undefined
-            && enddate === undefined && dbaction === undefined && dbactionuser === undefined);
+        const { resname, entname, vnum, filter, incdel, startdate, enddate, dbaction, dbactionuser, } = inputfilter;
+        return (resname !== undefined &&
+            entname === undefined &&
+            vnum === undefined &&
+            filter === undefined &&
+            incdel === undefined &&
+            startdate === undefined &&
+            enddate === undefined &&
+            dbaction === undefined &&
+            dbactionuser === undefined);
     }
     #buildQueryString(filters, restype) {
-        const { resname, entname, vnum, filter, incdel, startdate, enddate, dbaction, dbactionuser } = filters;
+        const { resname, entname, vnum, filter, incdel, startdate, enddate, dbaction, dbactionuser, } = filters;
         // Build query string
         const qparams = [];
-        let qstring = ' where ';
-        let sep = '';
+        let qstring = " where ";
+        let sep = "";
         let qnum = 0;
         if (resname !== undefined) {
             qparams.push(resname);
-            qstring += sep + 'r.resname = $' + ++qnum;
-            sep = ' and ';
+            qstring += sep + "r.resname = $" + ++qnum;
+            sep = " and ";
         }
         if (entname !== undefined) {
             qparams.push(entname);
-            qstring += sep + 'e.entname = $' + ++qnum;
-            sep = ' and ';
+            qstring += sep + "e.entname = $" + ++qnum;
+            sep = " and ";
         }
         if (vnum !== undefined) {
             qparams.push(vnum);
-            qstring += sep + restype + '.vnum = $' + ++qnum;
-            sep = ' and ';
+            qstring += sep + restype + ".vnum = $" + ++qnum;
+            sep = " and ";
         }
         else {
             // Only get current version provided enddate is not specified
             if (enddate === undefined) {
-                qstring += sep + restype + '.validto is null';
-                sep = ' and ';
+                qstring += sep + restype + ".validto is null";
+                sep = " and ";
             }
         }
         if (filter !== undefined) {
             qparams.push(filter);
-            if (restype === 'r') {
-                qstring += sep + restype + '.resname like $' + ++qnum;
+            if (restype === "r") {
+                qstring += sep + restype + ".resname like $" + ++qnum;
             }
             else {
-                qstring += sep + restype + '.entname like $' + ++qnum;
+                qstring += sep + restype + ".entname like $" + ++qnum;
             }
-            sep = ' and ';
+            sep = " and ";
         }
         if (startdate !== undefined) {
             qparams.push(startdate);
-            qstring += sep + restype + '.validfrom >= $' + ++qnum;
-            sep = ' and ';
+            qstring += sep + restype + ".validfrom >= $" + ++qnum;
+            sep = " and ";
         }
         if (enddate !== undefined) {
             qparams.push(enddate);
-            qstring += sep + restype + '.validto <= $' + ++qnum;
-            sep = ' and ';
+            qstring += sep + restype + ".validto <= $" + ++qnum;
+            sep = " and ";
         }
-        if (incdel === undefined || incdel.toLowerCase() === 'n') {
+        if (incdel === undefined || incdel.toLowerCase() === "n") {
             qparams.push(3);
-            qstring += sep + restype + '.dbaction != $' + ++qnum;
-            sep = ' and ';
+            qstring += sep + restype + ".dbaction != $" + ++qnum;
+            sep = " and ";
         }
         if (dbaction !== undefined) {
             qparams.push(dbaction);
-            qstring += sep + restype + '.dbaction = $' + ++qnum;
-            sep = ' and ';
+            qstring += sep + restype + ".dbaction = $" + ++qnum;
+            sep = " and ";
         }
         if (dbactionuser !== undefined) {
             qparams.push(dbactionuser);
-            qstring += sep + restype + '.dbactionuser = $' + ++qnum;
-            sep = ' and ';
+            qstring += sep + restype + ".dbactionuser = $" + ++qnum;
+            sep = " and ";
         }
         if (qnum === 0) {
             return null;
@@ -141,20 +148,24 @@ export class PGAccessLayer {
         await this.saveResource(systemUserId, defaultConfigId, config);
     }
     async getResourceCount(filter = null) {
-        const fname = 'getResourceCount';
+        const fname = "getResourceCount";
         try {
             let createQuery = `select count(*) from stsresource r`;
             if (filter !== null) {
-                createQuery += ' where ' + filter;
+                createQuery += " where " + filter;
             }
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(createQuery);
                 const dbResponse = rows[0];
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
             }
             finally {
                 client.release();
@@ -163,32 +174,40 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async createResource(userid, resourceid, payload) {
-        const fname = 'createResource';
+        const fname = "createResource";
         try {
             let createQuery = null;
             createQuery = `select * from create_stsresource($1, $2, $3)`;
-            const values = [
-                userid,
-                resourceid,
-                payload
-            ];
-            const client = await this.#poolManager?.connectReadWrite();
+            const values = [userid, resourceid, payload];
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
-                await client.query('BEGIN');
+                await client.query("BEGIN");
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows[0];
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 return { status: StatusCodes.CREATED, detail: dbResponse };
             }
             catch (error) {
-                await client.query('ROLLBACK');
-                let err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
-                if (error.code === '23505') {
-                    err = { status: StatusCodes.CONFLICT, error: `[${fname}: resourceid [${resourceid}] already exists`, detail: error };
+                await client.query("ROLLBACK");
+                let err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
+                if (error.code === "23505") {
+                    err = {
+                        status: StatusCodes.CONFLICT,
+                        error: `[${fname}: resourceid [${resourceid}] already exists`,
+                        detail: error,
+                    };
                 }
                 this.#LogDebugMessage(chalk.red(`Error: ${JSON.stringify(error)}`));
                 return err;
@@ -200,68 +219,81 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async beginX(readOnly) {
-        const fname = 'beginX';
+        const fname = "beginX";
         try {
             let client;
             if (readOnly) {
-                client = await this.#poolManager?.connectReadOnly();
+                client =
+                    (await this.#poolManager?.connectReadOnly());
             }
             else {
-                client = await this.#poolManager?.connectReadWrite();
+                client =
+                    (await this.#poolManager?.connectReadWrite());
             }
-            await client.query('BEGIN');
+            await client.query("BEGIN");
             return client;
         }
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async commitX(client) {
-        const fname = 'commitX';
+        const fname = "commitX";
         try {
-            await client.query('COMMIT');
+            await client.query("COMMIT");
             client.release();
         }
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async rollbackX(client) {
-        const fname = 'rollbackX';
+        const fname = "rollbackX";
         try {
-            await client.query('ROLLBACK');
+            await client.query("ROLLBACK");
             client.release();
         }
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async updateResource(userid, resourceid, resourcevnum, payload) {
-        const fname = 'updateResource';
+        const fname = "updateResource";
         try {
             const createQuery = `select * from update_stsresource($1, $2, $3, $4)`;
-            const values = [
-                userid,
-                resourceid,
-                resourcevnum,
-                payload
-            ];
-            const client = await this.#poolManager?.connectReadWrite();
+            const values = [userid, resourceid, resourcevnum, payload];
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
-                await client.query('BEGIN');
+                await client.query("BEGIN");
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows[0];
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 // Now remove this resource from the cache. Currently this does an unconditional remove without checking if updating current version
                 // and a race condition exists in that the database transaction is seperate from the cache update.
                 if (this.#ioredisCache !== null) {
@@ -270,10 +302,18 @@ export class PGAccessLayer {
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                await client.query('ROLLBACK');
-                let err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
-                if (error.code === 'P0002') {
-                    err = { status: StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] and version [${resourcevnum}] not found or not current`, detail: error };
+                await client.query("ROLLBACK");
+                let err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
+                if (error.code === "P0002") {
+                    err = {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: resourceid [${resourceid}] and version [${resourcevnum}] not found or not current`,
+                        detail: error,
+                    };
                 }
                 this.#LogDebugMessage(chalk.red(`updateResource(): Error: [${JSON.stringify(err)}]`));
                 return err;
@@ -285,14 +325,22 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async deleteLatestResource(userid, resid) {
-        const fname = 'deleteLatestResource';
+        const fname = "deleteLatestResource";
         const retVal = await this.getLatestResource(resid, false);
         if (retVal.status !== StatusCodes.OK) {
-            return { status: retVal.status, error: `[${fname}]: Operation was not successful: [${resid}]`, detail: retVal };
+            return {
+                status: retVal.status,
+                error: `[${fname}]: Operation was not successful: [${resid}]`,
+                detail: retVal,
+            };
         }
         else {
             const vnum = retVal.detail.vnum;
@@ -300,20 +348,16 @@ export class PGAccessLayer {
         }
     }
     async deleteResource(userid, resourceid, resourcevnum) {
-        const fname = 'deleteResource';
+        const fname = "deleteResource";
         try {
             const createQuery = `select * from delete_stsresource($1, $2, $3)`;
-            const values = [
-                userid,
-                resourceid,
-                resourcevnum
-            ];
-            const client = await this.#poolManager?.connectReadWrite();
+            const values = [userid, resourceid, resourcevnum];
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
-                await client.query('BEGIN');
+                await client.query("BEGIN");
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows[0];
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 // Now remove this resource from the cache. Currently this does an unconditional remove without checking if updating current version
                 // and a race condition exists in that the database transaction is seperate from the cache update.
                 if (this.#ioredisCache !== null) {
@@ -322,10 +366,18 @@ export class PGAccessLayer {
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                await client.query('ROLLBACK');
-                let err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
-                if (error.code === 'P0002') {
-                    err = { status: StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] and version [${resourcevnum}] not found or not current`, detail: error };
+                await client.query("ROLLBACK");
+                let err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
+                if (error.code === "P0002") {
+                    err = {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: resourceid [${resourceid}] and version [${resourcevnum}] not found or not current`,
+                        detail: error,
+                    };
                 }
                 this.#LogDebugMessage(chalk.red(`deleteResource(): Error: [${JSON.stringify(err)}]`));
                 return err;
@@ -337,11 +389,15 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async createEntity(userid, resourceid, resourcevnum, entityid, payload) {
-        const fname = 'createEntity';
+        const fname = "createEntity";
         try {
             const createQuery = `select * from create_stsentity($1, $2, $3, $4, $5)`;
             const values = [
@@ -349,21 +405,29 @@ export class PGAccessLayer {
                 resourceid,
                 resourcevnum,
                 entityid,
-                payload
+                payload,
             ];
-            const client = await this.#poolManager?.connectReadWrite();
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
-                await client.query('BEGIN');
+                await client.query("BEGIN");
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows[0];
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 return { status: StatusCodes.CREATED, detail: dbResponse };
             }
             catch (error) {
-                await client.query('ROLLBACK');
-                let err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
-                if (error.code === '23505') {
-                    err = { status: StatusCodes.CONFLICT, error: `[${fname}: entityid [${entityid}] already exists`, detail: error };
+                await client.query("ROLLBACK");
+                let err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
+                if (error.code === "23505") {
+                    err = {
+                        status: StatusCodes.CONFLICT,
+                        error: `[${fname}: entityid [${entityid}] already exists`,
+                        detail: error,
+                    };
                 }
                 this.#LogDebugMessage(chalk.red(`createEntity(): Error: [${JSON.stringify(err)}]`));
                 return err;
@@ -375,11 +439,15 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async createEntityEx(userid, resourceid, resourcevnum, entityid, entity) {
-        const fname = 'createEntity';
+        const fname = "createEntity";
         try {
             const createQuery = `select * from create_stsentity($1, $2, $3, $4, $5)`;
             const values = [
@@ -387,21 +455,29 @@ export class PGAccessLayer {
                 resourceid,
                 resourcevnum,
                 entityid,
-                JSON.stringify(entity)
+                JSON.stringify(entity),
             ];
-            const client = await this.#poolManager?.connectReadWrite();
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
-                await client.query('BEGIN');
-                const { rows } = (await client.query(createQuery, values));
+                await client.query("BEGIN");
+                const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows[0];
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 return { status: StatusCodes.CREATED, detail: dbResponse };
             }
             catch (error) {
-                await client.query('ROLLBACK');
-                let err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
-                if (error.code === '23505') {
-                    err = { status: StatusCodes.CONFLICT, error: `[${fname}: entityid [${entityid}] already exists`, detail: error };
+                await client.query("ROLLBACK");
+                let err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
+                if (error.code === "23505") {
+                    err = {
+                        status: StatusCodes.CONFLICT,
+                        error: `[${fname}: entityid [${entityid}] already exists`,
+                        detail: error,
+                    };
                 }
                 this.#LogDebugMessage(chalk.red(`createEntity(): Error: [${JSON.stringify(err)}]`));
                 return err;
@@ -413,11 +489,15 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async updateEntity(userid, resourceid, resourcevnum, entityid, entityvnum, payload) {
-        const fname = 'updateEntity';
+        const fname = "updateEntity";
         try {
             const createQuery = `select * from update_stsentity($1, $2, $3, $4, $5, $6)`;
             const values = [
@@ -426,21 +506,29 @@ export class PGAccessLayer {
                 resourcevnum,
                 entityid,
                 entityvnum,
-                payload
+                payload,
             ];
-            const client = await this.#poolManager?.connectReadWrite();
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
-                await client.query('BEGIN');
+                await client.query("BEGIN");
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows[0];
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                await client.query('ROLLBACK');
-                let err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
-                if (error.code === 'P0002') {
-                    err = { status: StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}:${resourcevnum}], entityid [${entityid}:${entityvnum}] not found or not current`, detail: error };
+                await client.query("ROLLBACK");
+                let err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
+                if (error.code === "P0002") {
+                    err = {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: resourceid [${resourceid}:${resourcevnum}], entityid [${entityid}:${entityvnum}] not found or not current`,
+                        detail: error,
+                    };
                 }
                 this.#LogDebugMessage(chalk.red(`updateEntity(): Error: [${JSON.stringify(err)}]`));
                 return err;
@@ -452,11 +540,15 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async deleteEntity(userid, resourceid, resourcevnum, entityid, entityvnum) {
-        const fname = 'deleteEntity';
+        const fname = "deleteEntity";
         try {
             const createQuery = `select * from delete_stsentity($1, $2, $3, $4, $5)`;
             const values = [
@@ -464,21 +556,29 @@ export class PGAccessLayer {
                 resourceid,
                 resourcevnum,
                 entityid,
-                entityvnum
+                entityvnum,
             ];
-            const client = await this.#poolManager?.connectReadWrite();
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
-                await client.query('BEGIN');
+                await client.query("BEGIN");
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows[0];
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                await client.query('ROLLBACK');
-                let err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
-                if (error.code === 'P0002') {
-                    err = { status: StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}:${resourcevnum}], entityid [${entityid}:${entityvnum}] not found or not current`, detail: error };
+                await client.query("ROLLBACK");
+                let err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
+                if (error.code === "P0002") {
+                    err = {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: resourceid [${resourceid}:${resourcevnum}], entityid [${entityid}:${entityvnum}] not found or not current`,
+                        detail: error,
+                    };
                 }
                 this.#LogDebugMessage(chalk.red(`deleteEntity(): Error: [${JSON.stringify(err)}]`));
                 return err;
@@ -490,17 +590,21 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     // get single resource and all associated entities for this resource
     async getResource(filters, useCache, usemultipledatabases = false) {
-        const fname = 'getResource';
+        const fname = "getResource";
         try {
-            let query = 'select r.oid::bigint, r.resname, r.resdesc, r.vnum::bigint, r.validfrom, r.validto, r.dbaction, r.dbactionuser from stsresource r';
+            let query = "select r.oid::bigint, r.resname, r.resdesc, r.vnum::bigint, r.validfrom, r.validto, r.dbaction, r.dbactionuser from stsresource r";
             let values = [];
             const resourceid = filters.resname;
-            const qs = this.#buildQueryString(filters, 'r');
+            const qs = this.#buildQueryString(filters, "r");
             if (qs !== null) {
                 query += qs.qstring;
                 values = qs.qparams;
@@ -510,34 +614,56 @@ export class PGAccessLayer {
                     const cacheVal = await this.#ioredisCache.get(resourceid);
                     if (cacheVal !== null) {
                         const cacheResponse = JSON.parse(cacheVal);
-                        return { status: StatusCodes.OK, usedcache: true, detail: cacheResponse };
+                        return {
+                            status: StatusCodes.OK,
+                            usedcache: true,
+                            detail: cacheResponse,
+                        };
                     }
                 }
             }
             query += " limit 2";
             let client;
             if (usemultipledatabases) {
-                client = await this.#poolManager?.connectReadOnly();
+                client =
+                    (await this.#poolManager?.connectReadOnly());
             }
             else {
-                client = await this.#poolManager?.connectReadWrite();
+                client =
+                    (await this.#poolManager?.connectReadWrite());
             }
             try {
                 const { rows } = await client.query(query, values);
                 if (rows.length === 0) {
-                    return { status: StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] (current version) not found`, detail: null };
+                    return {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: resourceid [${resourceid}] (current version) not found`,
+                        detail: null,
+                    };
                 }
                 if (rows.length > 1) {
-                    return { status: StatusCodes.NOT_FOUND, error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`, detail: null };
+                    return {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`,
+                        detail: null,
+                    };
                 }
                 const dbResponse = rows[0];
                 if (this.#ioredisCache !== null) {
                     this.#ioredisCache.set(resourceid, JSON.stringify(dbResponse));
                 }
-                return { status: StatusCodes.OK, usedcache: false, detail: dbResponse };
+                return {
+                    status: StatusCodes.OK,
+                    usedcache: false,
+                    detail: dbResponse,
+                };
             }
             catch (error) {
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default;
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default;
             }
             finally {
                 client.release();
@@ -546,17 +672,21 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     // get single resource and all associated entities for this resource
     async getResourceEx(filters) {
-        const fname = 'getResource';
+        const fname = "getResource";
         try {
-            let query = 'select r.oid::bigint, r.resname, r.resdesc, r.vnum::bigint, r.validfrom, r.validto, r.dbaction, r.dbactionuser from stsresource r';
+            let query = "select r.oid::bigint, r.resname, r.resdesc, r.vnum::bigint, r.validfrom, r.validto, r.dbaction, r.dbactionuser from stsresource r";
             let values = [];
             const resourceid = filters.resname;
-            const qs = this.#buildQueryString(filters, 'r');
+            const qs = this.#buildQueryString(filters, "r");
             if (qs !== null) {
                 query += qs.qstring;
                 values = qs.qparams;
@@ -572,28 +702,28 @@ export class PGAccessLayer {
                             // sts parsed values
                             status: StatusCodes.OK,
                             usedcache: true,
-                            detail: JSON.parse(cacheedResponse.resdesc)
+                            detail: JSON.parse(cacheedResponse.resdesc),
                         };
                         return retVal;
                     }
                 }
             }
             query += " limit 2";
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(query, values);
                 if (rows.length === 0) {
                     return {
                         status: StatusCodes.NOT_FOUND,
                         error: `[${fname}: resourceid [${resourceid}] (current version) not found`,
-                        usedcache: false
+                        usedcache: false,
                     };
                 }
                 if (rows.length > 1) {
                     return {
                         status: StatusCodes.NOT_FOUND,
                         error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`,
-                        usedcache: false
+                        usedcache: false,
                     };
                 }
                 const dbResponse = rows[0];
@@ -608,7 +738,7 @@ export class PGAccessLayer {
                         // sts parsed values
                         status: StatusCodes.OK,
                         usedcache: false,
-                        detail: parsedDetail
+                        detail: parsedDetail,
                     };
                 }
                 catch (error) {
@@ -618,7 +748,7 @@ export class PGAccessLayer {
                         status: StatusCodes.INTERNAL_SERVER_ERROR,
                         sourceError: error,
                         error: `[${fname}]: Operation was not successful - Could not JSON.parse(dbResponse.resdesc).`,
-                        usedcache: false
+                        usedcache: false,
                     };
                 }
             }
@@ -627,7 +757,7 @@ export class PGAccessLayer {
                     status: StatusCodes.INTERNAL_SERVER_ERROR,
                     sourceError: error,
                     error: `[${fname}]: Operation was not successful.`,
-                    usedcache: false
+                    usedcache: false,
                 };
             }
             finally {
@@ -641,17 +771,17 @@ export class PGAccessLayer {
                 status: StatusCodes.INTERNAL_SERVER_ERROR,
                 sourceError: error,
                 error: `[${fname}]: Operation was not successful - Fallback.`,
-                usedcache: false
+                usedcache: false,
             };
         }
     }
     // get single resource and all associated entities for this resource
     async getEntity(filters) {
-        const fname = 'getEntity';
+        const fname = "getEntity";
         try {
-            let query = 'select e.* from stsentity e join stsresource r on e.resourceoid = r.oid';
+            let query = "select e.* from stsentity e join stsresource r on e.resourceoid = r.oid";
             let values = [];
-            const qs = this.#buildQueryString(filters, 'e');
+            const qs = this.#buildQueryString(filters, "e");
             const resourceid = filters.resname;
             //let entityid = filters.entname;
             if (qs !== null) {
@@ -659,20 +789,32 @@ export class PGAccessLayer {
                 values = qs.qparams;
             }
             query += " limit 2";
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(query, values);
                 if (rows.length === 0) {
-                    return { status: StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] (current version) not found`, detail: null };
+                    return {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: resourceid [${resourceid}] (current version) not found`,
+                        detail: null,
+                    };
                 }
                 if (rows.length > 1) {
-                    return { status: StatusCodes.NOT_FOUND, error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`, detail: null };
+                    return {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`,
+                        detail: null,
+                    };
                 }
                 const dbResponse = rows[0];
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default;
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default;
             }
             finally {
                 client.release();
@@ -681,15 +823,19 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async getEntityEx(filters) {
-        const fname = 'getEntityEx';
+        const fname = "getEntityEx";
         try {
-            let query = 'select e.* from stsentity e join stsresource r on e.resourceoid = r.oid';
+            let query = "select e.* from stsentity e join stsresource r on e.resourceoid = r.oid";
             let values = [];
-            const qs = this.#buildQueryString(filters, 'e');
+            const qs = this.#buildQueryString(filters, "e");
             const resourceid = filters.resname;
             //let entityid = filters.entname;
             if (qs !== null) {
@@ -697,21 +843,33 @@ export class PGAccessLayer {
                 values = qs.qparams;
             }
             query += " limit 2";
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(query, values);
                 if (rows.length === 0) {
-                    return { status: StatusCodes.NOT_FOUND, error: `[${fname}: resourceid [${resourceid}] (current version) not found`, detail: null };
+                    return {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: resourceid [${resourceid}] (current version) not found`,
+                        detail: null,
+                    };
                 }
                 if (rows.length > 1) {
-                    return { status: StatusCodes.NOT_FOUND, error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`, detail: null };
+                    return {
+                        status: StatusCodes.NOT_FOUND,
+                        error: `[${fname}: Multiple resourceid [${resourceid}](current version) exist within database. Invalid database state.`,
+                        detail: null,
+                    };
                 }
                 const dbResponse = rows[0];
                 const parsedDetail = JSON.parse(dbResponse.entvalue);
                 return { status: StatusCodes.OK, detail: parsedDetail };
             }
             catch (error) {
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default;
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default;
             }
             finally {
                 client.release();
@@ -720,29 +878,37 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     // get single resource and all associated entities for this resource
     async getEntities(filters) {
-        const fname = 'getEntities';
+        const fname = "getEntities";
         try {
             let query = `select e.* from stsentity e join stsresource r on e.resourceoid = r.oid`;
             let values = [];
-            const qs = this.#buildQueryString(filters, 'e');
+            const qs = this.#buildQueryString(filters, "e");
             if (qs !== null) {
                 query += qs.qstring;
                 values = qs.qparams;
             }
             query += " limit 10";
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(query, values);
                 const dbResponse = rows;
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default;
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default;
             }
             finally {
                 client.release();
@@ -751,26 +917,30 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async getEntitiesEx(filters) {
-        const fname = 'getEntities';
+        const fname = "getEntities";
         try {
             let query = `select e.* from stsentity e join stsresource r on e.resourceoid = r.oid`;
             let values = [];
-            const qs = this.#buildQueryString(filters, 'e');
+            const qs = this.#buildQueryString(filters, "e");
             if (qs !== null) {
                 query += qs.qstring;
                 values = qs.qparams;
             }
             query += " limit 10";
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(query, values);
                 const dbResponse = rows;
                 const response = [];
-                dbResponse.forEach(r => {
+                dbResponse.forEach((r) => {
                     const obj = JSON.parse(r.entvalue);
                     r.entvalue = obj;
                     response.push(obj);
@@ -779,7 +949,11 @@ export class PGAccessLayer {
                 //return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default;
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default;
             }
             finally {
                 client.release();
@@ -788,29 +962,37 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     // get current resource
     async getResources(filters) {
-        const fname = 'getResources';
+        const fname = "getResources";
         try {
-            let query = 'select r.* from stsresource r';
+            let query = "select r.* from stsresource r";
             let values = [];
-            const qs = this.#buildQueryString(filters, 'r');
+            const qs = this.#buildQueryString(filters, "r");
             if (qs !== null) {
                 query += qs.qstring;
                 values = qs.qparams;
             }
             query += " limit 10";
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(query, values);
                 const dbResponse = rows;
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default;
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default;
             }
             finally {
                 client.release();
@@ -819,25 +1001,33 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async deleteResources(resname, actionuser) {
-        const fname = 'deleteResources';
+        const fname = "deleteResources";
         try {
-            const client = await this.#poolManager?.connectReadWrite();
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
-                const query = 'delete from stsresource where resname like $1 and dbactionuser = $2';
+                const query = "delete from stsresource where resname like $1 and dbactionuser = $2";
                 const values = [resname, actionuser];
-                await client.query('BEGIN');
+                await client.query("BEGIN");
                 await client.query(query, values);
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 return { status: StatusCodes.OK };
             }
             catch (error) {
                 this.#LogErrorMessage(`[${fname}]: Failed to delete resources: ${error}`);
-                await client.query('ROLLBACK');
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+                await client.query("ROLLBACK");
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                };
             }
             finally {
                 client.release();
@@ -846,25 +1036,33 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async deleteAllResources() {
-        const fname = 'createResource';
+        const fname = "createResource";
         try {
-            const client = await this.#poolManager?.connectReadWrite();
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
                 const query = "delete from stsresource";
                 //const query = "truncate stsresource cascade";
-                await client.query('BEGIN');
+                await client.query("BEGIN");
                 await client.query(query);
-                await client.query('COMMIT');
+                await client.query("COMMIT");
                 return { status: StatusCodes.OK };
             }
             catch (error) {
                 this.#LogErrorMessage(`[${fname}]: Failed to truncate table(s): ${error}`);
-                await client.query('ROLLBACK');
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+                await client.query("ROLLBACK");
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                };
             }
             finally {
                 client.release();
@@ -873,13 +1071,17 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async getTotalResources() {
-        const fname = 'getTotalResources';
+        const fname = "getTotalResources";
         try {
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 //const query = "delete from stsresource";
                 const query = "select count(*) from stsresource";
@@ -889,8 +1091,12 @@ export class PGAccessLayer {
             }
             catch (error) {
                 this.#LogErrorMessage(`[${fname}]: Could not get count from stsresource table: ${error}`);
-                await client.query('ROLLBACK');
-                return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+                await client.query("ROLLBACK");
+                return {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                };
             }
             finally {
                 client.release();
@@ -899,23 +1105,27 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async executedbscript(scriptfile) {
         try {
-            const fname = 'executedbscript';
-            const queryText = await fs.readFile(scriptfile, 'utf-8');
+            const fname = "executedbscript";
+            const queryText = await fs.readFile(scriptfile, "utf-8");
             try {
-                const client = await this.#poolManager?.connectReadWrite();
+                const client = (await this.#poolManager?.connectReadWrite());
                 try {
-                    await client.query('BEGIN');
+                    await client.query("BEGIN");
                     await client.query(queryText);
-                    await client.query('COMMIT');
+                    await client.query("COMMIT");
                     return `Completed executing file: ${scriptfile}`;
                 }
                 catch (error) {
-                    await client.query('ROLLBACK');
+                    await client.query("ROLLBACK");
                     this.#LogErrorMessage(`Error executing script: [${scriptfile}], Error: [${error}]`);
                     throw error;
                 }
@@ -967,27 +1177,29 @@ export class PGAccessLayer {
     }
     bulkInsert(fakerdata) {
         return new Promise((resolve, reject) => {
-            this.#poolManager?.connectReadWrite().then(client => {
+            this.#poolManager
+                ?.connectReadWrite()
+                .then((client) => {
                 const done = () => {
                     client.release();
-                    resolve('Completed');
+                    resolve("Completed");
                 };
                 /*
-                CREATE TABLE public.stsresource
-                oid bigint NOT NULL DEFAULT nextval('stsresource_oid_seq'::regclass),
-                resname character varying(80) COLLATE pg_catalog."default" NOT NULL,
-                resdesc character varying(32768) COLLATE pg_catalog."default",
-                vnum bigint NOT NULL,
-                validfrom timestamp without time zone NOT NULL,
-                validto timestamp without time zone,
-                dbaction smallint NOT NULL,
-                dbactionuser character varying(64) COLLATE pg_catalog."default" NOT NULL,
-                */
+            CREATE TABLE public.stsresource
+            oid bigint NOT NULL DEFAULT nextval('stsresource_oid_seq'::regclass),
+            resname character varying(80) COLLATE pg_catalog."default" NOT NULL,
+            resdesc character varying(32768) COLLATE pg_catalog."default",
+            vnum bigint NOT NULL,
+            validfrom timestamp without time zone NOT NULL,
+            validto timestamp without time zone,
+            dbaction smallint NOT NULL,
+            dbactionuser character varying(64) COLLATE pg_catalog."default" NOT NULL,
+            */
                 //insert into stsresource(resname, resdesc, vnum, dbaction, dbactionuser, validfrom)
                 //values (_resname, _resdesc, 1, 1, _dbactionuser, __now);
                 //var stream = client.query(copyFrom('COPY stsresource (oid,resname,resdesc,vnum,validfrom,validto,dbaction,dbactionuser) FROM STDIN'));
-                const stream = client.query(copyFrom('COPY stsresource (resname,resdesc,vnum,validfrom,dbaction,dbactionuser) FROM STDIN'));
-                const rs = new streamex.Readable;
+                const stream = client.query(copyFrom("COPY stsresource (resname,resdesc,vnum,validfrom,dbaction,dbactionuser) FROM STDIN"));
+                const rs = new streamex.Readable();
                 let currentIndex = 0;
                 rs._read = function () {
                     if (currentIndex === fakerdata.length) {
@@ -997,15 +1209,20 @@ export class PGAccessLayer {
                         const data = fakerdata[currentIndex];
                         rs.push(
                         //data.oid
-                        data.resname
-                            //+ '\t' + data.resname 
-                            + '\t' + data.resdesc
-                            + '\t' + data.vnum
-                            + '\t' + data.validfrom
-                            //+ '\t' + data.validto 
-                            + '\t' + data.dbaction
-                            + '\t' + data.dbactionuser
-                            + '\n');
+                        data.resname +
+                            //+ '\t' + data.resname
+                            "\t" +
+                            data.resdesc +
+                            "\t" +
+                            data.vnum +
+                            "\t" +
+                            data.validfrom +
+                            //+ '\t' + data.validto
+                            "\t" +
+                            data.dbaction +
+                            "\t" +
+                            data.dbactionuser +
+                            "\n");
                         currentIndex++;
                     }
                 };
@@ -1013,27 +1230,32 @@ export class PGAccessLayer {
                     client.release();
                     reject(strErr);
                 };
-                rs.on('error', onError);
-                stream.on('error', onError);
-                stream.on('finish', done);
+                rs.on("error", onError);
+                stream.on("error", onError);
+                stream.on("finish", done);
                 rs.pipe(stream);
-            }).catch(error => {
+            })
+                .catch((error) => {
                 this.#LogErrorMessage(error);
             });
         });
     }
     async GetMonitorSummary() {
-        const fname = 'GetMonitorSummary';
+        const fname = "GetMonitorSummary";
         try {
             const createQuery = `select * from get_monitor_summary()`;
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(createQuery);
                 const dbResponse = rows;
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                const err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
+                const err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
                 this.#LogDebugMessage(chalk.red(`Error: ${JSON.stringify(error)}`));
                 return err;
             }
@@ -1044,22 +1266,30 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async GetMonitorSummaryByServiceId(serviceId) {
-        const fname = 'GetMonitorSummaryByServiceId';
+        const fname = "GetMonitorSummaryByServiceId";
         try {
             const createQuery = `select * from get_monitor_summary_by_serviceid($1)`;
             const values = [serviceId];
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows;
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                const err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
+                const err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
                 this.#LogDebugMessage(chalk.red(`Error: ${JSON.stringify(error)}`));
                 return err;
             }
@@ -1070,22 +1300,30 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async GetMonitorSummaryByServiceInstanceId(serviceInstanceId) {
-        const fname = 'GetMonitorSummaryByServiceInstanceId';
+        const fname = "GetMonitorSummaryByServiceInstanceId";
         try {
             const createQuery = `select * from get_monitor_summary_by_serviceinstanceid($1)`;
             const values = [serviceInstanceId];
-            const client = await this.#poolManager?.connectReadOnly();
+            const client = (await this.#poolManager?.connectReadOnly());
             try {
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows;
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                const err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
+                const err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
                 this.#LogDebugMessage(chalk.red(`Error: ${JSON.stringify(error)}`));
                 return err;
             }
@@ -1096,22 +1334,30 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
     async PurgeOldMonitorData(keepAgeSeconds) {
-        const fname = 'GetMonitorSummaryByServiceInstanceId';
+        const fname = "GetMonitorSummaryByServiceInstanceId";
         try {
             const createQuery = `select * from purge_old_monitor_data($1)`;
             const values = [keepAgeSeconds];
-            const client = await this.#poolManager?.connectReadWrite();
+            const client = (await this.#poolManager?.connectReadWrite());
             try {
                 const { rows } = await client.query(createQuery, values);
                 const dbResponse = rows[0];
                 return { status: StatusCodes.OK, detail: dbResponse };
             }
             catch (error) {
-                const err = { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error }; // Set default
+                const err = {
+                    status: StatusCodes.INTERNAL_SERVER_ERROR,
+                    error: `[${fname}]: Operation was not successful`,
+                    detail: error,
+                }; // Set default
                 this.#LogDebugMessage(chalk.red(`Error: ${JSON.stringify(error)}`));
                 return err;
             }
@@ -1122,7 +1368,11 @@ export class PGAccessLayer {
         catch (error) {
             // Error getting the client connection from the pool
             this.#LogErrorMessage(`[${fname}]: Could not get client from pool: ${error}`);
-            return { status: StatusCodes.INTERNAL_SERVER_ERROR, error: `[${fname}]: Operation was not successful`, detail: error };
+            return {
+                status: StatusCodes.INTERNAL_SERVER_ERROR,
+                error: `[${fname}]: Operation was not successful`,
+                detail: error,
+            };
         }
     }
 }