@nsshunt/stsdatamanagement 1.18.199 → 1.18.201

package/dist/pcaccesslayer-entity.test.js

@@ -1,15 +1,15 @@
 /* eslint @typescript-eslint/no-explicit-any: 0 */ // --> OFF
-import { beforeAll, afterAll, test, describe, expect } from 'vitest';
-import chalk from 'chalk';
-import { goptions, $ResetOptions } from '@nsshunt/stsconfig';
-import { defaultLogger, Sleep, edbaction } from '@nsshunt/stsutils';
-import { DatabaseUtils } from './databaseutils.js';
+import { beforeAll, afterAll, test, describe, expect } from "vitest";
+import chalk from "chalk";
+import { goptions, $ResetOptions } from "@nsshunt/stsconfig";
+import { defaultLogger, Sleep, edbaction, } from "@nsshunt/stsutils";
+import { DatabaseUtils } from "./databaseutils.js";
 import { GenericContainer } from "testcontainers";
-import winston from 'winston';
-import { DBAccessLayerManager } from './dbAccessLayerManager.js';
-import { accessLayerType, eOperations } from './commonTypes.js';
-import { StatusCodes } from 'http-status-codes';
-const dbactionuser = 'jesttest';
+import winston from "winston";
+import { DBAccessLayerManager } from "./dbAccessLayerManager.js";
+import { accessLayerType, eOperations, } from "./commonTypes.js";
+import { StatusCodes } from "http-status-codes";
+const dbactionuser = "jesttest";
 const sort = (a, b) => {
     if (a.detail && b.detail) {
         return a.detail.entname.localeCompare(b.detail.entname);
@@ -23,19 +23,17 @@ describe("Test pgaccesslayer", () => {
     let accessLayer;
     const finalResults = {};
     const userResourceType = {
-        name: 'user-t2',
-        notes: 'user-t2 notes',
-        code: 1
+        name: "user-t2",
+        notes: "user-t2 notes",
+        code: 1,
     };
     let resourceoid = "";
     beforeAll(async () => {
         winston.format.combine(winston.format.colorize(), winston.format.simple());
         const logger = winston.createLogger({
-            level: 'silly',
+            level: "silly",
             format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
-            transports: [
-                new winston.transports.Console(),
-            ]
+            transports: [new winston.transports.Console()],
         });
         postgresContainer = await new GenericContainer("postgres")
             .withExposedPorts(5432)
@@ -43,13 +41,13 @@ describe("Test pgaccesslayer", () => {
             POSTGRES_PASSWORD: "postgres",
             //UV_THREADPOOL_SIZE: "64"
         })
-            .withCommand(['-c', 'max_connections=20'])
+            .withCommand(["-c", "max_connections=20"])
             .start();
         await Sleep(1000);
         const postgresHttpPort = postgresContainer.getMappedPort(5432);
         const postgresHost = postgresContainer.getHost();
         process.env.DB_HOST = `${postgresHost}:${postgresHttpPort}`;
-        process.env.POOL_SIZE = '10';
+        process.env.POOL_SIZE = "10";
         $ResetOptions();
         logger.info(chalk.green(`httpPort: [${postgresHttpPort}]`));
         logger.info(chalk.green(`host: [${postgresHost}]`));
@@ -60,11 +58,11 @@ describe("Test pgaccesslayer", () => {
             iterations: 10000,
             minextradata: 0,
             maxextradata: 1000,
-            workerScriptFolder: './dist', //@@
-            useMultiBar: false
+            workerScriptFolder: "./dist", //@@
+            useMultiBar: false,
         };
         const dbUtils = new DatabaseUtils({
-            logger
+            logger,
         });
         await dbUtils.CreateDatabase(dbOptions);
         await Sleep(1000);
@@ -73,19 +71,19 @@ describe("Test pgaccesslayer", () => {
             accessLayerType: accessLayerType.postgresql,
             accessLayerOptions: {
                 logger: defaultLogger,
-                usedefaultdb: false
-            }
+                usedefaultdb: false,
+            },
         });
         logger.info(chalk.green(`accessLayer:startdatabase()`));
         await accessLayer.StartDatabase();
     }, 120000);
-    test('Testing Database Entity create, update, patch, read and delete', async () => {
+    test("Testing Database Entity create, update, patch, read and delete", async () => {
         expect.assertions(30);
         const userResourceOptions = {
             filters: {
                 dbactionuser,
-                resname: userResourceType.name
-            }
+                resname: userResourceType.name,
+            },
         };
         const userResourceTypeCreateRecord = await accessLayer.CreateResource(userResourceOptions, userResourceType);
         const matchCreateResource = {
@@ -99,7 +97,7 @@ describe("Test pgaccesslayer", () => {
                 resname: userResourceType.name,
                 validto: null,
                 vnum: "1",
-            }
+            },
         };
         const createdResource = userResourceTypeCreateRecord.detail;
         expect(userResourceTypeCreateRecord).toMatchObject(matchCreateResource);
@@ -107,17 +105,17 @@ describe("Test pgaccesslayer", () => {
         expect(new Date(createdResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         resourceoid = createdResource.oid;
         const userEntity01 = {
-            userId: 'user01',
-            userName: 'user01 name',
+            userId: "user01",
+            userName: "user01 name",
             count: 1,
-            description: `user01 description`
+            description: `user01 description`,
         };
         const entityResourceOptions = {
             filters: {
                 dbactionuser,
                 resname: userResourceType.name,
-                entname: userEntity01.userId
-            }
+                entname: userEntity01.userId,
+            },
         };
         // Create Record -------------------------------------------------------------------------------------
         const entityUser01CreateRecord = await accessLayer.CreateEntity(entityResourceOptions, userEntity01);
@@ -133,7 +131,7 @@ describe("Test pgaccesslayer", () => {
                 entname: userEntity01.userId,
                 validto: null,
                 vnum: "1",
-            }
+            },
         };
         const createdEntity = entityUser01CreateRecord.detail;
         expect(entityUser01CreateRecord).toMatchObject(matchCreateEntity);
@@ -145,7 +143,7 @@ describe("Test pgaccesslayer", () => {
             operation: eOperations.GetEntityCount,
             options: entityResourceOptions,
             status: StatusCodes.OK,
-            detail: 1
+            detail: 1,
         };
         expect(entityCountPostCreate).toMatchObject(matchEntityCountPostCreate);
         // Get Record -------------------------------------------------------------------------------------
@@ -162,7 +160,7 @@ describe("Test pgaccesslayer", () => {
                 entname: userEntity01.userId,
                 validto: null,
                 vnum: "1",
-            }
+            },
         };
         const getEntityRecord = getRecord1.detail;
         expect(getRecord1).toMatchObject(matchGetEntity);
@@ -171,9 +169,9 @@ describe("Test pgaccesslayer", () => {
         // Update Record -------------------------------------------------------------------------------------
         const updateEntityResource = {
             userId: userEntity01.userId,
-            userName: 'user01 name update',
+            userName: "user01 name update",
             count: 2,
-            description: `user01 description update`
+            description: `user01 description update`,
         };
         const userEntity01UpdateRecord = await accessLayer.UpdateEntity(entityResourceOptions, updateEntityResource);
         const matchUpdateEntity = {
@@ -188,7 +186,7 @@ describe("Test pgaccesslayer", () => {
                 entname: updateEntityResource.userId,
                 validto: null,
                 vnum: "2",
-            }
+            },
         };
         const updateEntityRecord = userEntity01UpdateRecord.detail;
         expect(userEntity01UpdateRecord).toMatchObject(matchUpdateEntity);
@@ -197,7 +195,7 @@ describe("Test pgaccesslayer", () => {
         // Patch Record -------------------------------------------------------------------------------------
         const patchEntityResource = {
             userId: userEntity01.userId,
-            userName: 'user01 name patched'
+            userName: "user01 name patched",
         };
         const userEntity01PatchRecord = await accessLayer.PatchEntity(entityResourceOptions, patchEntityResource);
         const matchPatchedEntity = {
@@ -212,7 +210,7 @@ describe("Test pgaccesslayer", () => {
                 entname: patchEntityResource.userId,
                 validto: null,
                 vnum: "3",
-            }
+            },
         };
         const patchedEntityRecord = userEntity01PatchRecord.detail;
         expect(userEntity01PatchRecord).toMatchObject(matchPatchedEntity);
@@ -232,7 +230,7 @@ describe("Test pgaccesslayer", () => {
                 entname: patchEntityResource.userId,
                 validto: null,
                 vnum: "4",
-            }
+            },
         };
         const deletedEntityRecord = userEntity01DeleteRecord.detail;
         expect(userEntity01DeleteRecord).toMatchObject(matchDeletedEntity);
@@ -247,8 +245,8 @@ describe("Test pgaccesslayer", () => {
             detail: null,
             error: {
                 operation: eOperations.GetEntity,
-                status: StatusCodes.NOT_FOUND
-            }
+                status: StatusCodes.NOT_FOUND,
+            },
         };
         expect(getDeleted).toMatchObject(matchGetDeletedEntity);
         expect(getDeleted.error?.errorMessage).toMatch(/\(current version\) not found/);
@@ -258,7 +256,7 @@ describe("Test pgaccesslayer", () => {
             operation: eOperations.GetEntityCount,
             options: entityResourceOptions,
             status: StatusCodes.OK,
-            detail: 0
+            detail: 0,
         };
         expect(entityCountPostDelete).toMatchObject(matchEntityCountPostDelete);
         // Create Additional Entities -------------------------------------------------------------------------------------
@@ -270,14 +268,14 @@ describe("Test pgaccesslayer", () => {
                 userId,
                 userName: `${userId} name`,
                 count: 2,
-                description: `${userId} description`
+                description: `${userId} description`,
             };
             const entityResourceOptions = {
                 filters: {
                     dbactionuser,
                     resname: userResourceType.name,
-                    entname: userEntity.userId
-                }
+                    entname: userEntity.userId,
+                },
             };
             const entityCreateRecord = await accessLayer.CreateEntity(entityResourceOptions, userEntity);
             expDetail.push(entityCreateRecord.detail);
@@ -293,7 +291,7 @@ describe("Test pgaccesslayer", () => {
                     entname: userEntity.userId,
                     validto: null,
                     vnum: "1",
-                }
+                },
             };
             const createdEntityRecord = entityCreateRecord.detail;
             expect(entityCreateRecord).toMatchObject(matchCreateEntity);
@@ -303,44 +301,44 @@ describe("Test pgaccesslayer", () => {
         // Get Entities (using filters) -------------------------------------------------------------------------------------
         const entities = await accessLayer.GetEntities({
             filters: {
-                resname: 'user-t2',
-                filter: '%'
-            }
+                resname: "user-t2",
+                filter: "%",
+            },
         });
         expect(entities.detail).toMatchObject(expDetail);
         // Get Entity Count Post Delete -------------------------------------------------------------------------------------
         const entityCountOptions = {
             filters: {
-                resname: 'user-t2'
-            }
+                resname: "user-t2",
+            },
         };
         const entityCountPostMultiCreate = await accessLayer.GetEntityCount(entityCountOptions);
         const matchEntityCountPostMultiCreate = {
             operation: eOperations.GetEntityCount,
             options: entityCountOptions,
             status: StatusCodes.OK,
-            detail: createCount
+            detail: createCount,
         };
         expect(entityCountPostMultiCreate).toMatchObject(matchEntityCountPostMultiCreate);
     }, 120000);
-    test('Testing Database Entity Batch Create', async () => {
+    test("Testing Database Entity Batch Create", async () => {
         const createStart = 100;
         const createNum = 60;
         expect.assertions(180);
         for (let i = createStart; i < createStart + createNum; i++) {
-            const userId = `user_${String(i).padStart(4, '0')}`;
+            const userId = `user_${String(i).padStart(4, "0")}`;
             const createUserEntity = {
                 userId,
                 userName: `${userId} name`,
                 count: i,
-                description: `${userId} description`
+                description: `${userId} description`,
             };
             const userCreateRecord = await accessLayer.CreateEntity({
                 filters: {
                     dbactionuser,
                     resname: userResourceType.name,
-                    entname: createUserEntity.userId
-                }
+                    entname: createUserEntity.userId,
+                },
             }, createUserEntity);
             const checkObject = {
                 status: StatusCodes.CREATED,
@@ -348,11 +346,11 @@ describe("Test pgaccesslayer", () => {
                     entname: createUserEntity.userId,
                     entvalue: createUserEntity,
                     resourceoid,
-                    vnum: '1',
+                    vnum: "1",
                     validto: null,
                     dbaction: edbaction.created,
-                    dbactionuser
-                }
+                    dbactionuser,
+                },
             };
             const createdRecord = userCreateRecord.detail;
             finalResults[createdRecord.entname] = createdRecord;
@@ -361,29 +359,29 @@ describe("Test pgaccesslayer", () => {
             expect(parseInt(createdRecord.oid)).toBeGreaterThan(0);
         }
     }, 120000);
-    test('Testing Database Entity Batch Create using Update', async () => {
+    test("Testing Database Entity Batch Create using Update", async () => {
         const updateStart = 100;
         const updateNum = 5;
         expect.assertions(15);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = updateStart; i < updateStart + updateNum; i++) {
-            const userId = `user_new_${String(i).padStart(4, '0')}`;
+            const userId = `user_new_${String(i).padStart(4, "0")}`;
             const createFromUpdateUserEntity = {
                 userId,
                 userName: `${userId} name`,
                 count: i,
-                description: `${userId} description`
+                description: `${userId} description`,
             };
             const resourceParameterRecord = {
                 opitons: {
                     filters: {
                         dbactionuser,
                         resname: userResourceType.name,
-                        entname: createFromUpdateUserEntity.userId
-                    }
+                        entname: createFromUpdateUserEntity.userId,
+                    },
                 },
-                entity: createFromUpdateUserEntity
+                entity: createFromUpdateUserEntity,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
@@ -395,10 +393,10 @@ describe("Test pgaccesslayer", () => {
                     vnum: "1",
                     validto: null,
                     dbaction: edbaction.created,
-                    dbactionuser
+                    dbactionuser,
                 },
                 operation: eOperations.UpdateEntities,
-                options: {}
+                options: {},
             };
             testRecords.push(testObject);
         }
@@ -409,36 +407,38 @@ describe("Test pgaccesslayer", () => {
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
-                const updatedResourceRecord = retVal[i].detail;
-                finalResults[updatedResourceRecord.entname] = updatedResourceRecord;
+                const updatedResourceRecord = retVal[i]
+                    .detail;
+                finalResults[updatedResourceRecord.entname] =
+                    updatedResourceRecord;
                 expect(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
                 expect(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    test('Testing Database Entity Batch Update', async () => {
+    test("Testing Database Entity Batch Update", async () => {
         const updateStart = 100;
         const updateNum = 5;
         expect.assertions(15);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = updateStart; i < updateStart + updateNum; i++) {
-            const userId = `user_${String(i).padStart(4, '0')}`;
+            const userId = `user_${String(i).padStart(4, "0")}`;
             const createFromUpdateUserEntity = {
                 userId,
                 userName: `${userId} updated name`,
                 count: i + 1000,
-                description: `${userId} updated description`
+                description: `${userId} updated description`,
             };
             const resourceParameterRecord = {
                 opitons: {
                     filters: {
                         dbactionuser,
                         resname: userResourceType.name,
-                        entname: createFromUpdateUserEntity.userId
-                    }
+                        entname: createFromUpdateUserEntity.userId,
+                    },
                 },
-                entity: createFromUpdateUserEntity
+                entity: createFromUpdateUserEntity,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
@@ -450,10 +450,10 @@ describe("Test pgaccesslayer", () => {
                     vnum: "2",
                     validto: null,
                     dbaction: edbaction.updated,
-                    dbactionuser
+                    dbactionuser,
                 },
                 operation: eOperations.UpdateEntities,
-                options: {}
+                options: {},
             };
             testRecords.push(testObject);
         }
@@ -464,14 +464,16 @@ describe("Test pgaccesslayer", () => {
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
-                const updatedResourceRecord = retVal[i].detail;
-                finalResults[updatedResourceRecord.entname] = updatedResourceRecord;
+                const updatedResourceRecord = retVal[i]
+                    .detail;
+                finalResults[updatedResourceRecord.entname] =
+                    updatedResourceRecord;
                 expect(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
                 expect(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    test('Testing Database Entity Batch Update with Errors', async () => {
+    test("Testing Database Entity Batch Update with Errors", async () => {
         const updateErrorStart = 110;
         const updateErrorNum = 5;
         const updateErrorIndex = 112;
@@ -479,26 +481,26 @@ describe("Test pgaccesslayer", () => {
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = updateErrorStart; i < updateErrorStart + updateErrorNum; i++) {
-            let userId = `user_${String(i).padStart(4, '0')}`;
+            let userId = `user_${String(i).padStart(4, "0")}`;
             if (i === updateErrorIndex) {
-                userId = `user_error_${String(i).padStart(4, '0')}`;
+                userId = `user_error_${String(i).padStart(4, "0")}`;
             }
             const createFromUpdateUserEntity = {
                 userId,
                 userName: `${userId} updated name`,
                 count: i + 1000,
-                description: `${userId} updated description`
+                description: `${userId} updated description`,
             };
             const resourceParameterRecord = {
                 opitons: {
                     filters: {
                         dbactionuser,
                         resname: userResourceType.name,
-                        entname: createFromUpdateUserEntity.userId
+                        entname: createFromUpdateUserEntity.userId,
                     },
-                    errorOnBatchUpdate: true // We want errors instead of create new records
+                    errorOnBatchUpdate: true, // We want errors instead of create new records
                 },
-                entity: createFromUpdateUserEntity
+                entity: createFromUpdateUserEntity,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === updateErrorIndex) {
@@ -509,8 +511,8 @@ describe("Test pgaccesslayer", () => {
                     options: {},
                     error: {
                         operation: eOperations.GetEntity,
-                        status: StatusCodes.NOT_FOUND
-                    }
+                        status: StatusCodes.NOT_FOUND,
+                    },
                 };
                 testRecords.push(testObject);
             }
@@ -519,7 +521,7 @@ describe("Test pgaccesslayer", () => {
                     status: StatusCodes.OK,
                     detail: null,
                     operation: eOperations.UpdateEntities,
-                    options: {}
+                    options: {},
                 };
                 testRecords.push(testObject);
             }
@@ -532,46 +534,50 @@ describe("Test pgaccesslayer", () => {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
                 if (retVal[i].error) {
-                    const updatedResourceRecordError = retVal[i].error;
-                    const entName = retVal[i].options.filters.entname;
+                    const updatedResourceRecordError = retVal[i]
+                        .error;
+                    const entName = retVal[i].options.filters
+                        .entname;
                     finalResults[entName] = updatedResourceRecordError;
                     expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
-                    const entName = retVal[i].options.filters.entname;
+                    const entName = retVal[i].options.filters
+                        .entname;
                     const missingResource = await accessLayer.GetEntity(retVal[i].options);
-                    finalResults[entName] = missingResource.detail;
+                    finalResults[entName] =
+                        missingResource.detail;
                 }
             }
         }
     }, 120000);
-    test('Testing Database Entity Batch Patch', async () => {
+    test("Testing Database Entity Batch Patch", async () => {
         const patchStart = 120;
         const patchNum = 5;
         expect.assertions(15);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = patchStart; i < patchStart + patchNum; i++) {
-            const userId = `user_${String(i).padStart(4, '0')}`;
+            const userId = `user_${String(i).padStart(4, "0")}`;
             const recordPatch = {
                 userId,
-                description: `${userId} patched description`
+                description: `${userId} patched description`,
             };
             const recordPostPatch = {
                 userId,
                 userName: `${userId} name`,
                 count: i,
-                description: recordPatch.description
+                description: recordPatch.description,
             };
             const resourceParameterRecord = {
                 opitons: {
                     filters: {
                         dbactionuser,
                         resname: userResourceType.name,
-                        entname: recordPatch.userId
-                    }
+                        entname: recordPatch.userId,
+                    },
                 },
-                entity: recordPatch
+                entity: recordPatch,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
@@ -583,10 +589,10 @@ describe("Test pgaccesslayer", () => {
                     vnum: "2",
                     validto: null,
                     dbaction: edbaction.updated,
-                    dbactionuser
+                    dbactionuser,
                 },
                 operation: eOperations.PatchEntities,
-                options: {}
+                options: {},
             };
             testRecords.push(testObject);
         }
@@ -597,14 +603,16 @@ describe("Test pgaccesslayer", () => {
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
-                const updatedResourceRecord = retVal[i].detail;
-                finalResults[updatedResourceRecord.entname] = updatedResourceRecord;
+                const updatedResourceRecord = retVal[i]
+                    .detail;
+                finalResults[updatedResourceRecord.entname] =
+                    updatedResourceRecord;
                 expect(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
                 expect(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    test('Testing Database Entity Batch Patch with Errors', async () => {
+    test("Testing Database Entity Batch Patch with Errors", async () => {
         const patchErrorStart = 130;
         const patchErrorNum = 5;
         const patchErrorIndex = 132;
@@ -612,13 +620,13 @@ describe("Test pgaccesslayer", () => {
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = patchErrorStart; i < patchErrorStart + patchErrorNum; i++) {
-            let userId = `user_${String(i).padStart(4, '0')}`;
+            let userId = `user_${String(i).padStart(4, "0")}`;
             if (i === patchErrorIndex) {
-                userId = `user_error_${String(i).padStart(4, '0')}`;
+                userId = `user_error_${String(i).padStart(4, "0")}`;
             }
             const recordPatch = {
                 userId,
-                description: `${userId} patched description`
+                description: `${userId} patched description`,
             };
             /*
             const recordPostPatch: Partial<IUserEntity> = {
@@ -632,11 +640,11 @@ describe("Test pgaccesslayer", () => {
                     filters: {
                         dbactionuser,
                         resname: userResourceType.name,
-                        entname: recordPatch.userId
+                        entname: recordPatch.userId,
                     },
-                    errorOnBatchUpdate: true // We want errors instead of create new records                    
+                    errorOnBatchUpdate: true, // We want errors instead of create new records
                 },
-                entity: recordPatch
+                entity: recordPatch,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === patchErrorIndex) {
@@ -647,8 +655,8 @@ describe("Test pgaccesslayer", () => {
                     options: {},
                     error: {
                         operation: eOperations.GetEntity,
-                        status: StatusCodes.NOT_FOUND
-                    }
+                        status: StatusCodes.NOT_FOUND,
+                    },
                 };
                 testRecords.push(testObject);
             }
@@ -657,7 +665,7 @@ describe("Test pgaccesslayer", () => {
                     status: StatusCodes.OK,
                     detail: null,
                     operation: eOperations.PatchEntities,
-                    options: {}
+                    options: {},
                 };
                 testRecords.push(testObject);
             }
@@ -670,27 +678,31 @@ describe("Test pgaccesslayer", () => {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
                 if (retVal[i].error) {
-                    const patchedResourceRecordError = retVal[i].error;
-                    const entname = retVal[i].options.filters.entname;
+                    const patchedResourceRecordError = retVal[i]
+                        .error;
+                    const entname = retVal[i].options.filters
+                        .entname;
                     finalResults[entname] = patchedResourceRecordError;
                     expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
-                    const entname = retVal[i].options.filters.entname;
+                    const entname = retVal[i].options.filters
+                        .entname;
                     const missingResource = await accessLayer.GetEntity(retVal[i].options);
-                    finalResults[entname] = missingResource.detail;
+                    finalResults[entname] =
+                        missingResource.detail;
                 }
             }
         }
     }, 120000);
-    test('Testing Database Entity Batch Delete', async () => {
+    test("Testing Database Entity Batch Delete", async () => {
         const deleteStart = 140;
         const deleteNum = 5;
         expect.assertions(15);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = deleteStart; i < deleteStart + deleteNum; i++) {
-            const userId = `user_${String(i).padStart(4, '0')}`;
+            const userId = `user_${String(i).padStart(4, "0")}`;
             const recordDelete = {
                 userId,
             };
@@ -698,17 +710,17 @@ describe("Test pgaccesslayer", () => {
                 userId,
                 userName: `${userId} name`,
                 count: i,
-                description: `${userId} description`
+                description: `${userId} description`,
             };
             const resourceParameterRecord = {
                 opitons: {
                     filters: {
                         dbactionuser,
                         resname: userResourceType.name,
-                        entname: recordDelete.userId
-                    }
+                        entname: recordDelete.userId,
+                    },
                 },
-                entity: recordDelete
+                entity: recordDelete,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
@@ -720,10 +732,10 @@ describe("Test pgaccesslayer", () => {
                     vnum: "2",
                     validto: null,
                     dbaction: edbaction.deleted,
-                    dbactionuser
+                    dbactionuser,
                 },
                 operation: eOperations.DeleteEntities,
-                options: {}
+                options: {},
             };
             testRecords.push(testObject);
         }
@@ -734,14 +746,16 @@ describe("Test pgaccesslayer", () => {
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
-                const updatedResourceRecord = retVal[i].detail;
-                finalResults[updatedResourceRecord.entname] = updatedResourceRecord;
+                const updatedResourceRecord = retVal[i]
+                    .detail;
+                finalResults[updatedResourceRecord.entname] =
+                    updatedResourceRecord;
                 expect(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
                 expect(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    test('Testing Database Entity Batch Delete with Errors', async () => {
+    test("Testing Database Entity Batch Delete with Errors", async () => {
         const deleteErrorStart = 150;
         const deleteErrorNum = 5;
         const deleteErrorIndex = 152;
@@ -749,9 +763,9 @@ describe("Test pgaccesslayer", () => {
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = deleteErrorStart; i < deleteErrorStart + deleteErrorNum; i++) {
-            let userId = `user_${String(i).padStart(4, '0')}`;
+            let userId = `user_${String(i).padStart(4, "0")}`;
             if (i === deleteErrorIndex) {
-                userId = `user_error_${String(i).padStart(4, '0')}`;
+                userId = `user_error_${String(i).padStart(4, "0")}`;
             }
             const recordDelete = {
                 userId,
@@ -761,11 +775,11 @@ describe("Test pgaccesslayer", () => {
                     filters: {
                         dbactionuser,
                         resname: userResourceType.name,
-                        entname: recordDelete.userId
+                        entname: recordDelete.userId,
                     },
-                    errorOnBatchUpdate: true // We want errors instead of create new records                    
+                    errorOnBatchUpdate: true, // We want errors instead of create new records
                 },
-                entity: recordDelete
+                entity: recordDelete,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === deleteErrorIndex) {
@@ -776,8 +790,8 @@ describe("Test pgaccesslayer", () => {
                     options: {},
                     error: {
                         operation: eOperations.GetEntity,
-                        status: StatusCodes.NOT_FOUND
-                    }
+                        status: StatusCodes.NOT_FOUND,
+                    },
                 };
                 testRecords.push(testObject);
             }
@@ -786,7 +800,7 @@ describe("Test pgaccesslayer", () => {
                     status: StatusCodes.OK,
                     detail: null,
                     operation: eOperations.DeleteEntities,
-                    options: {}
+                    options: {},
                 };
                 testRecords.push(testObject);
             }
@@ -799,31 +813,35 @@ describe("Test pgaccesslayer", () => {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
                 if (retVal[i].error) {
-                    const patchedResourceRecordError = retVal[i].error;
-                    const entname = retVal[i].options.filters.entname;
+                    const patchedResourceRecordError = retVal[i]
+                        .error;
+                    const entname = retVal[i].options.filters
+                        .entname;
                     finalResults[entname] = patchedResourceRecordError;
                     expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
-                    const entname = retVal[i].options.filters.entname;
+                    const entname = retVal[i].options.filters
+                        .entname;
                     const missingResource = await accessLayer.GetEntity(retVal[i].options);
-                    finalResults[entname] = missingResource.detail;
+                    finalResults[entname] =
+                        missingResource.detail;
                 }
             }
         }
     }, 120000);
-    test('Get All user_patch_test_ Resources', async () => {
+    test("Get All user_patch_test_ Resources", async () => {
         expect.assertions(51);
         // All Records
         const AllRecords = await accessLayer.GetEntities({
             filters: {
                 resname: userResourceType.name,
-                filter: 'user_%',
-                limit: '50'
-            }
+                filter: "user_%",
+                limit: "50",
+            },
         });
         expect(AllRecords.detail.length).toEqual(50);
-        AllRecords.detail.forEach(u => {
+        AllRecords.detail.forEach((u) => {
             const compareObject = finalResults[u.entname];
             if (compareObject) {
                 expect(u).toMatchObject(compareObject);
@@ -833,42 +851,46 @@ describe("Test pgaccesslayer", () => {
         // Output formatted table
         const columns = [
             {
-                name: 'userId',
+                name: "userId",
                 width: 30,
                 left: true,
-                field: 'userId'
+                field: "userId",
             },
             {
-                name: 'userName',
+                name: "userName",
                 width: 30,
                 left: true,
-                field: 'userName'
+                field: "userName",
             },
             {
-                name: 'description',
+                name: "description",
                 width: 50,
                 left: true,
-                field: 'description'
+                field: "description",
             },
             {
-                name: 'count',
+                name: "count",
                 width: 10,
                 left: false,
-                field: 'count'
-            }
+                field: "count",
+            },
         ];
-        let header = '';
+        let header = "";
         let length = 0;
-        columns.forEach(c => {
-            header += (c.left ? c.name.padEnd(c.width) : c.name.padStart(c.width));
+        columns.forEach((c) => {
+            header += c.left
+                ? c.name.padEnd(c.width)
+                : c.name.padStart(c.width);
             length += c.width;
         });
         console.log(header);
-        console.log('-'.repeat(length));
-        AllRecords.detail.forEach(u => {
-            let detail = '';
-            columns.forEach(c => {
-                detail += (c.left ? u.entvalue[c.field].toString().padEnd(c.width) : u.entvalue[c.field].toString().padStart(c.width));
+        console.log("-".repeat(length));
+        AllRecords.detail.forEach((u) => {
+            let detail = "";
+            columns.forEach((c) => {
+                detail += c.left
+                    ? u.entvalue[c.field].toString().padEnd(c.width)
+                    : u.entvalue[c.field].toString().padStart(c.width);
             });
             console.log(detail);
         });