@nsshunt/stsdatamanagement 1.18.200 → 1.18.201

package/dist/pcaccesslayer.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.resname.localeCompare(b.detail.resname);
@@ -25,11 +25,9 @@ describe("Test pgaccesslayer", () => {
     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)
@@ -37,13 +35,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}]`));
@@ -54,11 +52,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);
@@ -67,13 +65,13 @@ 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 Resource create, update, patch, read and delete', async () => {
+    test("Testing Database Resource create, update, patch, read and delete", async () => {
         expect.assertions(22);
         const initialCount = await accessLayer.GetResourceCount();
         expect(initialCount.detail).toEqual(20000);
@@ -81,13 +79,13 @@ describe("Test pgaccesslayer", () => {
         const userResourceType = {
             name: `user`,
             notes: `user notes`,
-            code: 1
+            code: 1,
         };
         const userResourceOptions = {
             filters: {
                 dbactionuser,
-                resname: userResourceType.name
-            }
+                resname: userResourceType.name,
+            },
         };
         const userResourceTypeCreateRecord = await accessLayer.CreateResource(userResourceOptions, userResourceType);
         const matchCreateResource = {
@@ -101,7 +99,7 @@ describe("Test pgaccesslayer", () => {
                 resname: userResourceType.name,
                 validto: null,
                 vnum: "1",
-            }
+            },
         };
         const createdResource = userResourceTypeCreateRecord.detail;
         expect(userResourceTypeCreateRecord).toMatchObject(matchCreateResource);
@@ -114,7 +112,7 @@ describe("Test pgaccesslayer", () => {
             operation: eOperations.GetResourceCount,
             options: {},
             status: StatusCodes.OK,
-            detail: 20001
+            detail: 20001,
         };
         expect(count).toMatchObject(matchGetResourceCount);
         // Get Record -------------------------------------------------------------------------------------
@@ -130,7 +128,7 @@ describe("Test pgaccesslayer", () => {
                 resname: userResourceType.name,
                 validto: null,
                 vnum: "1",
-            }
+            },
         };
         const getResource = getRecord1.detail;
         expect(getRecord1).toMatchObject(matchGetResource);
@@ -140,7 +138,7 @@ describe("Test pgaccesslayer", () => {
         const updateUserResource = {
             name: userResourceType.name,
             notes: `Updated notes`,
-            code: 2
+            code: 2,
         };
         const userResourceTypeUpdateRecord = await accessLayer.UpdateResource(userResourceOptions, updateUserResource);
         const matchUpdateResource = {
@@ -154,7 +152,7 @@ describe("Test pgaccesslayer", () => {
                 resname: userResourceType.name,
                 validto: null,
                 vnum: "2",
-            }
+            },
         };
         const updatedResource = userResourceTypeUpdateRecord.detail;
         expect(userResourceTypeUpdateRecord).toMatchObject(matchUpdateResource);
@@ -176,12 +174,12 @@ describe("Test pgaccesslayer", () => {
                 resdesc: {
                     name: userResourceType.name,
                     notes: patchUserResource.notes,
-                    code: 2
+                    code: 2,
                 },
                 resname: userResourceType.name,
                 validto: null,
                 vnum: "3",
-            }
+            },
         };
         const patchedResource = patchResourceRecord.detail;
         expect(patchResourceRecord).toMatchObject(matchPatchResource);
@@ -199,12 +197,12 @@ describe("Test pgaccesslayer", () => {
                 resdesc: {
                     name: userResourceType.name,
                     notes: patchUserResource.notes,
-                    code: 2
+                    code: 2,
                 },
                 resname: userResourceType.name,
                 validto: null,
                 vnum: "4",
-            }
+            },
         };
         const deletedResource = userResourceTypeDeleteRecord.detail;
         expect(userResourceTypeDeleteRecord).toMatchObject(matchDeleteResource);
@@ -219,8 +217,8 @@ describe("Test pgaccesslayer", () => {
             detail: null,
             error: {
                 operation: eOperations.GetResource,
-                status: StatusCodes.NOT_FOUND
-            }
+                status: StatusCodes.NOT_FOUND,
+            },
         };
         expect(getDeletedRecord).toMatchObject(matchNotFoundResource);
         expect(getDeletedRecord.error?.errorMessage).toMatch(/\(current version\) not found/);
@@ -230,30 +228,30 @@ describe("Test pgaccesslayer", () => {
             operation: eOperations.GetResourceCount,
             options: {},
             status: StatusCodes.OK,
-            detail: 20000
+            detail: 20000,
         };
         expect(resourceCountPostDelete).toMatchObject(matchResourceCountPostDelete);
         // Get Resources using filter -------------------------------------------------------------------------------------
         const resources = await accessLayer.GetResources({
             filters: {
-                filter: 'RESCP-%',
-                limit: '10',
-            }
+                filter: "RESCP-%",
+                limit: "10",
+            },
         });
         expect(resources.detail.length).toEqual(10);
     }, 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 userResourceType = {
-            name: 'user-t2',
-            notes: 'user-t2 notes',
-            code: 1
+            name: "user-t2",
+            notes: "user-t2 notes",
+            code: 1,
         };
         const userResourceOptions = {
             filters: {
                 dbactionuser,
-                resname: userResourceType.name
-            }
+                resname: userResourceType.name,
+            },
         };
         const userResourceTypeCreateRecord = await accessLayer.CreateResource(userResourceOptions, userResourceType);
         const matchCreateResource = {
@@ -267,7 +265,7 @@ describe("Test pgaccesslayer", () => {
                 resname: userResourceType.name,
                 validto: null,
                 vnum: "1",
-            }
+            },
         };
         const createdResource = userResourceTypeCreateRecord.detail;
         expect(userResourceTypeCreateRecord).toMatchObject(matchCreateResource);
@@ -275,17 +273,17 @@ describe("Test pgaccesslayer", () => {
         expect(new Date(createdResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         const resOid = 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);
@@ -301,7 +299,7 @@ describe("Test pgaccesslayer", () => {
                 entname: userEntity01.userId,
                 validto: null,
                 vnum: "1",
-            }
+            },
         };
         const createdEntity = entityUser01CreateRecord.detail;
         expect(entityUser01CreateRecord).toMatchObject(matchCreateEntity);
@@ -313,7 +311,7 @@ describe("Test pgaccesslayer", () => {
             operation: eOperations.GetEntityCount,
             options: entityResourceOptions,
             status: StatusCodes.OK,
-            detail: 1
+            detail: 1,
         };
         expect(entityCountPostCreate).toMatchObject(matchEntityCountPostCreate);
         // Get Record -------------------------------------------------------------------------------------
@@ -330,7 +328,7 @@ describe("Test pgaccesslayer", () => {
                 entname: userEntity01.userId,
                 validto: null,
                 vnum: "1",
-            }
+            },
         };
         const getEntityRecord = getRecord1.detail;
         expect(getRecord1).toMatchObject(matchGetEntity);
@@ -339,9 +337,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 = {
@@ -356,7 +354,7 @@ describe("Test pgaccesslayer", () => {
                 entname: updateEntityResource.userId,
                 validto: null,
                 vnum: "2",
-            }
+            },
         };
         const updateEntityRecord = userEntity01UpdateRecord.detail;
         expect(userEntity01UpdateRecord).toMatchObject(matchUpdateEntity);
@@ -365,7 +363,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 = {
@@ -380,7 +378,7 @@ describe("Test pgaccesslayer", () => {
                 entname: patchEntityResource.userId,
                 validto: null,
                 vnum: "3",
-            }
+            },
         };
         const patchedEntityRecord = userEntity01PatchRecord.detail;
         expect(userEntity01PatchRecord).toMatchObject(matchPatchedEntity);
@@ -400,7 +398,7 @@ describe("Test pgaccesslayer", () => {
                 entname: patchEntityResource.userId,
                 validto: null,
                 vnum: "4",
-            }
+            },
         };
         const deletedEntityRecord = userEntity01DeleteRecord.detail;
         expect(userEntity01DeleteRecord).toMatchObject(matchDeletedEntity);
@@ -415,8 +413,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/);
@@ -426,7 +424,7 @@ describe("Test pgaccesslayer", () => {
             operation: eOperations.GetEntityCount,
             options: entityResourceOptions,
             status: StatusCodes.OK,
-            detail: 0
+            detail: 0,
         };
         expect(entityCountPostDelete).toMatchObject(matchEntityCountPostDelete);
         // Create Additional Entities -------------------------------------------------------------------------------------
@@ -437,14 +435,14 @@ describe("Test pgaccesslayer", () => {
                 userId: `user_${i}`,
                 userName: `user_${i} name`,
                 count: 2,
-                description: `user_${i} description`
+                description: `user_${i} 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);
@@ -460,7 +458,7 @@ describe("Test pgaccesslayer", () => {
                     entname: userEntity.userId,
                     validto: null,
                     vnum: "1",
-                }
+                },
             };
             const createdEntityRecord = entityCreateRecord.detail;
             expect(entityCreateRecord).toMatchObject(matchCreateEntity);
@@ -470,23 +468,23 @@ 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);
@@ -1101,7 +1099,7 @@ describe("Test pgaccesslayer", () => {
         });
     }, 120000);
     */
-    test('Testing Database Resource Batch Create', async () => {
+    test("Testing Database Resource Batch Create", async () => {
         const createStart = 100;
         const createNum = 60;
         expect.assertions(180);
@@ -1114,19 +1112,19 @@ describe("Test pgaccesslayer", () => {
             const userResourceTypeCreateRecord = await accessLayer.CreateResource({
                 filters: {
                     dbactionuser,
-                    resname: userResourceType.name
-                }
+                    resname: userResourceType.name,
+                },
             }, userResourceType);
             const checkObject = {
                 status: StatusCodes.CREATED,
                 detail: {
                     resname: userResourceType.name,
                     resdesc: userResourceType,
-                    vnum: '1',
+                    vnum: "1",
                     validto: null,
                     dbaction: edbaction.created,
-                    dbactionuser
-                }
+                    dbactionuser,
+                },
             };
             const createdResourceRecord = userResourceTypeCreateRecord.detail;
             finalResults[createdResourceRecord.resname] = createdResourceRecord;
@@ -1135,7 +1133,7 @@ describe("Test pgaccesslayer", () => {
             expect(parseInt(createdResourceRecord.oid)).toBeGreaterThan(0);
         }
     }, 120000);
-    test('Testing Database Resource Batch Create using Update', async () => {
+    test("Testing Database Resource Batch Create using Update", async () => {
         const updateStart = 100;
         const updateNum = 5;
         expect.assertions(15);
@@ -1146,16 +1144,16 @@ describe("Test pgaccesslayer", () => {
             const userResourceTypePatch = {
                 name,
                 notes: `New record for user: [${i}]`,
-                code: i + 5000
+                code: i + 5000,
             };
             const resourceParameterRecord = {
                 opitons: {
                     filters: {
                         dbactionuser,
                         resname: userResourceTypePatch.name,
-                    }
+                    },
                 },
-                resource: userResourceTypePatch
+                resource: userResourceTypePatch,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
@@ -1166,10 +1164,10 @@ describe("Test pgaccesslayer", () => {
                     vnum: "1",
                     validto: null,
                     dbaction: edbaction.created,
-                    dbactionuser
+                    dbactionuser,
                 },
                 operation: eOperations.UpdateResources,
-                options: {}
+                options: {},
             };
             testRecords.push(testObject);
         }
@@ -1180,14 +1178,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.resname] = updatedResourceRecord;
+                const updatedResourceRecord = retVal[i]
+                    .detail;
+                finalResults[updatedResourceRecord.resname] =
+                    updatedResourceRecord;
                 expect(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
                 expect(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    test('Testing Database Resource Batch Update', async () => {
+    test("Testing Database Resource Batch Update", async () => {
         const updateStart = 100;
         const updateNum = 5;
         expect.assertions(15);
@@ -1198,16 +1198,16 @@ describe("Test pgaccesslayer", () => {
             const userResourceTypePatch = {
                 name,
                 notes: `Updated notes for user: [${i}]`,
-                code: i + 1000
+                code: i + 1000,
             };
             const resourceParameterRecord = {
                 opitons: {
                     filters: {
                         dbactionuser,
                         resname: userResourceTypePatch.name,
-                    }
+                    },
                 },
-                resource: userResourceTypePatch
+                resource: userResourceTypePatch,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
@@ -1218,10 +1218,10 @@ describe("Test pgaccesslayer", () => {
                     vnum: "2",
                     validto: null,
                     dbaction: edbaction.updated,
-                    dbactionuser
+                    dbactionuser,
                 },
                 operation: eOperations.UpdateResources,
-                options: {}
+                options: {},
             };
             testRecords.push(testObject);
         }
@@ -1232,14 +1232,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.resname] = updatedResourceRecord;
+                const updatedResourceRecord = retVal[i]
+                    .detail;
+                finalResults[updatedResourceRecord.resname] =
+                    updatedResourceRecord;
                 expect(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
                 expect(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    test('Testing Database Resource Batch Update with Errors', async () => {
+    test("Testing Database Resource Batch Update with Errors", async () => {
         const updateErrorStart = 110;
         const updateErrorNum = 5;
         const updateErrorIndex = 112;
@@ -1254,7 +1256,7 @@ describe("Test pgaccesslayer", () => {
             const userResourceTypePatch = {
                 name,
                 notes: `Updated notes for user: [${i}]`,
-                code: i + 1000
+                code: i + 1000,
             };
             const resourceParameterRecord = {
                 opitons: {
@@ -1262,9 +1264,9 @@ describe("Test pgaccesslayer", () => {
                         dbactionuser,
                         resname: userResourceTypePatch.name,
                     },
-                    errorOnBatchUpdate: true // We want errors instead of create new records
+                    errorOnBatchUpdate: true, // We want errors instead of create new records
                 },
-                resource: userResourceTypePatch
+                resource: userResourceTypePatch,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === updateErrorIndex) {
@@ -1275,8 +1277,8 @@ describe("Test pgaccesslayer", () => {
                     options: {},
                     error: {
                         operation: eOperations.GetResource,
-                        status: StatusCodes.NOT_FOUND
-                    }
+                        status: StatusCodes.NOT_FOUND,
+                    },
                 };
                 testRecords.push(testObject);
             }
@@ -1285,7 +1287,7 @@ describe("Test pgaccesslayer", () => {
                     status: StatusCodes.OK,
                     detail: null,
                     operation: eOperations.UpdateResources,
-                    options: {}
+                    options: {},
                 };
                 testRecords.push(testObject);
             }
@@ -1298,20 +1300,24 @@ 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 resName = retVal[i].options.filters.resname;
+                    const updatedResourceRecordError = retVal[i]
+                        .error;
+                    const resName = retVal[i].options.filters
+                        .resname;
                     finalResults[resName] = updatedResourceRecordError;
                     expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
-                    const resName = retVal[i].options.filters.resname;
+                    const resName = retVal[i].options.filters
+                        .resname;
                     const missingResource = await accessLayer.GetResource(retVal[i].options);
-                    finalResults[resName] = missingResource.detail;
+                    finalResults[resName] =
+                        missingResource.detail;
                 }
             }
         }
     }, 120000);
-    test('Testing Database Resource Batch Patch', async () => {
+    test("Testing Database Resource Batch Patch", async () => {
         const patchStart = 120;
         const patchNum = 5;
         expect.assertions(15);
@@ -1321,21 +1327,21 @@ describe("Test pgaccesslayer", () => {
             const name = `user_patch_test_${i}`;
             const userResourceTypePatch = {
                 name,
-                notes: `Patched notes for user: [${i}]`
+                notes: `Patched notes for user: [${i}]`,
             };
             const userResourceTypePostPatch = {
                 name,
                 notes: userResourceTypePatch.notes,
-                code: i // Note that the original code from the create should remain the same
+                code: i, // Note that the original code from the create should remain the same
             };
             const resourceParameterRecord = {
                 opitons: {
                     filters: {
                         dbactionuser,
                         resname: userResourceTypePatch.name,
-                    }
+                    },
                 },
-                resource: userResourceTypePatch
+                resource: userResourceTypePatch,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
@@ -1346,10 +1352,10 @@ describe("Test pgaccesslayer", () => {
                     vnum: "2",
                     validto: null,
                     dbaction: edbaction.updated,
-                    dbactionuser
+                    dbactionuser,
                 },
                 operation: eOperations.PatchResources,
-                options: {}
+                options: {},
             };
             testRecords.push(testObject);
         }
@@ -1360,14 +1366,16 @@ describe("Test pgaccesslayer", () => {
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
-                const patchedResourceRecord = retVal[i].detail;
-                finalResults[patchedResourceRecord.resname] = patchedResourceRecord;
+                const patchedResourceRecord = retVal[i]
+                    .detail;
+                finalResults[patchedResourceRecord.resname] =
+                    patchedResourceRecord;
                 expect(new Date(patchedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
                 expect(parseInt(patchedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    test('Testing Database Resource Batch Patch with Errors', async () => {
+    test("Testing Database Resource Batch Patch with Errors", async () => {
         const patchErrorStart = 130;
         const patchErrorNum = 5;
         const patchErrorIndex = 132;
@@ -1381,7 +1389,7 @@ describe("Test pgaccesslayer", () => {
             }
             const userResourceTypePatch = {
                 name,
-                notes: `Patched notes for user: [${i}]`
+                notes: `Patched notes for user: [${i}]`,
             };
             const resourceParameterRecord = {
                 opitons: {
@@ -1389,9 +1397,9 @@ describe("Test pgaccesslayer", () => {
                         dbactionuser,
                         resname: userResourceTypePatch.name,
                     },
-                    errorOnBatchUpdate: true // We want errors instead of create new records
+                    errorOnBatchUpdate: true, // We want errors instead of create new records
                 },
-                resource: userResourceTypePatch
+                resource: userResourceTypePatch,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === patchErrorIndex) {
@@ -1402,8 +1410,8 @@ describe("Test pgaccesslayer", () => {
                     options: {},
                     error: {
                         operation: eOperations.GetResource,
-                        status: StatusCodes.NOT_FOUND
-                    }
+                        status: StatusCodes.NOT_FOUND,
+                    },
                 };
                 testRecords.push(testObject);
             }
@@ -1412,7 +1420,7 @@ describe("Test pgaccesslayer", () => {
                     status: StatusCodes.OK,
                     detail: null,
                     operation: eOperations.PatchResources,
-                    options: {}
+                    options: {},
                 };
                 testRecords.push(testObject);
             }
@@ -1425,20 +1433,24 @@ 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 resName = retVal[i].options.filters.resname;
+                    const patchedResourceRecordError = retVal[i]
+                        .error;
+                    const resName = retVal[i].options.filters
+                        .resname;
                     finalResults[resName] = patchedResourceRecordError;
                     expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
-                    const resName = retVal[i].options.filters.resname;
+                    const resName = retVal[i].options.filters
+                        .resname;
                     const missingResource = await accessLayer.GetResource(retVal[i].options);
-                    finalResults[resName] = missingResource.detail;
+                    finalResults[resName] =
+                        missingResource.detail;
                 }
             }
         }
     }, 120000);
-    test('Testing Database Resource Batch Delete', async () => {
+    test("Testing Database Resource Batch Delete", async () => {
         const deleteStart = 140;
         const deleteNum = 5;
         expect.assertions(15);
@@ -1459,9 +1471,9 @@ describe("Test pgaccesslayer", () => {
                     filters: {
                         dbactionuser,
                         resname: userResourceTypeDelete.name,
-                    }
+                    },
                 },
-                resource: userResourceTypeDelete
+                resource: userResourceTypeDelete,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
@@ -1472,10 +1484,10 @@ describe("Test pgaccesslayer", () => {
                     vnum: "2",
                     validto: null,
                     dbaction: edbaction.deleted,
-                    dbactionuser
+                    dbactionuser,
                 },
                 operation: eOperations.DeleteResources,
-                options: {}
+                options: {},
             };
             testRecords.push(testObject);
         }
@@ -1486,14 +1498,16 @@ describe("Test pgaccesslayer", () => {
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
-                const deletedResourceRecord = retVal[i].detail;
-                finalResults[deletedResourceRecord.resname] = deletedResourceRecord;
+                const deletedResourceRecord = retVal[i]
+                    .detail;
+                finalResults[deletedResourceRecord.resname] =
+                    deletedResourceRecord;
                 expect(new Date(deletedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
                 expect(parseInt(deletedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    test('Testing Database Resource Batch Delete with Error', async () => {
+    test("Testing Database Resource Batch Delete with Error", async () => {
         const deleteErrorStart = 150;
         const deleteErrorNum = 5;
         const deleteErrorIndex = 152;
@@ -1513,9 +1527,9 @@ describe("Test pgaccesslayer", () => {
                     filters: {
                         dbactionuser,
                         resname: userResourceTypeDelete.name,
-                    }
+                    },
                 },
-                resource: userResourceTypeDelete
+                resource: userResourceTypeDelete,
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === deleteErrorIndex) {
@@ -1526,8 +1540,8 @@ describe("Test pgaccesslayer", () => {
                     options: {},
                     error: {
                         operation: eOperations.GetResource,
-                        status: StatusCodes.NOT_FOUND
-                    }
+                        status: StatusCodes.NOT_FOUND,
+                    },
                 };
                 testRecords.push(testObject);
             }
@@ -1536,7 +1550,7 @@ describe("Test pgaccesslayer", () => {
                     status: StatusCodes.OK,
                     detail: null,
                     operation: eOperations.DeleteResources,
-                    options: {}
+                    options: {},
                 };
                 testRecords.push(testObject);
             }
@@ -1549,30 +1563,34 @@ describe("Test pgaccesslayer", () => {
             for (let i = 0; i < retVal.length; i++) {
                 expect(retVal[i]).toMatchObject(testRecords[i]);
                 if (retVal[i].error) {
-                    const deletedResourceRecordError = retVal[i].error;
-                    const resName = retVal[i].options.filters.resname;
+                    const deletedResourceRecordError = retVal[i]
+                        .error;
+                    const resName = retVal[i].options.filters
+                        .resname;
                     finalResults[resName] = deletedResourceRecordError;
                     expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
-                    const resName = retVal[i].options.filters.resname;
+                    const resName = retVal[i].options.filters
+                        .resname;
                     const missingResource = await accessLayer.GetResource(retVal[i].options);
-                    finalResults[resName] = missingResource.detail;
+                    finalResults[resName] =
+                        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.GetResources({
             filters: {
-                filter: 'user_patch_test_%',
-                limit: '50'
-            }
+                filter: "user_patch_test_%",
+                limit: "50",
+            },
         });
         expect(AllRecords.detail.length).toEqual(50);
-        AllRecords.detail.forEach(u => {
+        AllRecords.detail.forEach((u) => {
             const compareObject = finalResults[u.resname];
             if (compareObject) {
                 expect(u).toMatchObject(compareObject);
@@ -1582,36 +1600,40 @@ describe("Test pgaccesslayer", () => {
         // Output formatted table
         const columns = [
             {
-                name: 'Name',
+                name: "Name",
                 width: 30,
                 left: true,
-                field: 'name'
+                field: "name",
             },
             {
-                name: 'Notes',
+                name: "Notes",
                 width: 50,
                 left: true,
-                field: 'notes'
+                field: "notes",
             },
             {
-                name: 'Code',
+                name: "Code",
                 width: 10,
                 left: false,
-                field: 'code'
-            }
+                field: "code",
+            },
         ];
-        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.resdesc[c.field].toString().padEnd(c.width) : u.resdesc[c.field].toString().padStart(c.width));
+        console.log("-".repeat(length));
+        AllRecords.detail.forEach((u) => {
+            let detail = "";
+            columns.forEach((c) => {
+                detail += c.left
+                    ? u.resdesc[c.field].toString().padEnd(c.width)
+                    : u.resdesc[c.field].toString().padStart(c.width);
             });
             console.log(detail);
         });