@nsshunt/stsdatamanagement 1.18.178 → 1.18.179

package/dist/pcaccesslayer.test.js

@@ -1,19 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint @typescript-eslint/no-explicit-any: 0 */ // --> OFF
-const vitest_1 = require("vitest");
-const chalk_1 = __importDefault(require("chalk"));
-const stsconfig_1 = require("@nsshunt/stsconfig");
-const stsutils_1 = require("@nsshunt/stsutils");
-const databaseutils_js_1 = require("./databaseutils.js");
-const testcontainers_1 = require("testcontainers");
-const winston_1 = __importDefault(require("winston"));
-const dbAccessLayerManager_js_1 = require("./dbAccessLayerManager.js");
-const commonTypes_js_1 = require("./commonTypes.js");
-const http_status_codes_1 = require("http-status-codes");
+import { beforeAll, afterAll, test, describe, expect } from 'vitest';
+import chalk from 'chalk';
+import { goptions, $ResetOptions } from '@nsshunt/stsconfig';
+import { JestSleep, 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';
 const sort = (a, b) => {
     if (a.detail && b.detail) {
@@ -23,20 +18,20 @@ const sort = (a, b) => {
         return -1;
     }
 };
-(0, vitest_1.describe)("Test pgaccesslayer", () => {
+describe("Test pgaccesslayer", () => {
     let postgresContainer;
     let accessLayer;
     const finalResults = {};
-    (0, vitest_1.beforeAll)(async () => {
-        winston_1.default.format.combine(winston_1.default.format.colorize(), winston_1.default.format.simple());
-        const logger = winston_1.default.createLogger({
+    beforeAll(async () => {
+        winston.format.combine(winston.format.colorize(), winston.format.simple());
+        const logger = winston.createLogger({
             level: 'silly',
-            format: winston_1.default.format.combine(winston_1.default.format.colorize(), winston_1.default.format.simple()),
+            format: winston.format.combine(winston.format.colorize(), winston.format.simple()),
             transports: [
-                new winston_1.default.transports.Console(),
+                new winston.transports.Console(),
             ]
         });
-        postgresContainer = await new testcontainers_1.GenericContainer("postgres")
+        postgresContainer = await new GenericContainer("postgres")
             .withExposedPorts(5432)
             .withEnvironment({
             POSTGRES_PASSWORD: "postgres",
@@ -44,16 +39,16 @@ const sort = (a, b) => {
         })
             .withCommand(['-c', 'max_connections=20'])
             .start();
-        await (0, stsutils_1.Sleep)(1000);
+        await Sleep(1000);
         const postgresHttpPort = postgresContainer.getMappedPort(5432);
         const postgresHost = postgresContainer.getHost();
         process.env.DB_HOST = `${postgresHost}:${postgresHttpPort}`;
         process.env.POOL_SIZE = '10';
-        (0, stsconfig_1.$ResetOptions)();
-        logger.info(chalk_1.default.green(`httpPort: [${postgresHttpPort}]`));
-        logger.info(chalk_1.default.green(`host: [${postgresHost}]`));
-        logger.info(chalk_1.default.yellow(`connectionString: [${stsconfig_1.goptions.connectionString}]`));
-        logger.info(chalk_1.default.yellow(`defaultDatabaseConnectionString: [${stsconfig_1.goptions.defaultDatabaseConnectionString}]`));
+        $ResetOptions();
+        logger.info(chalk.green(`httpPort: [${postgresHttpPort}]`));
+        logger.info(chalk.green(`host: [${postgresHost}]`));
+        logger.info(chalk.yellow(`connectionString: [${goptions.connectionString}]`));
+        logger.info(chalk.yellow(`defaultDatabaseConnectionString: [${goptions.defaultDatabaseConnectionString}]`));
         const dbOptions = {
             start: 0,
             iterations: 10000,
@@ -62,26 +57,26 @@ const sort = (a, b) => {
             workerScriptFolder: './dist', //@@
             useMultiBar: false
         };
-        const dbUtils = new databaseutils_js_1.DatabaseUtils({
+        const dbUtils = new DatabaseUtils({
             logger
         });
         await dbUtils.CreateDatabase(dbOptions);
-        await (0, stsutils_1.Sleep)(1000);
-        logger.info(chalk_1.default.green(`Starting accessLayer`));
-        accessLayer = new dbAccessLayerManager_js_1.DBAccessLayerManager().CreateAccessLayer({
-            accessLayerType: commonTypes_js_1.accessLayerType.postgresql,
+        await Sleep(1000);
+        logger.info(chalk.green(`Starting accessLayer`));
+        accessLayer = new DBAccessLayerManager().CreateAccessLayer({
+            accessLayerType: accessLayerType.postgresql,
             accessLayerOptions: {
-                logger: stsutils_1.defaultLogger,
+                logger: defaultLogger,
                 usedefaultdb: false
             }
         });
-        logger.info(chalk_1.default.green(`accessLayer:startdatabase()`));
+        logger.info(chalk.green(`accessLayer:startdatabase()`));
         await accessLayer.StartDatabase();
     }, 120000);
-    (0, vitest_1.test)('Testing Database Resource create, update, patch, read and delete', async () => {
-        vitest_1.expect.assertions(22);
+    test('Testing Database Resource create, update, patch, read and delete', async () => {
+        expect.assertions(22);
         const initialCount = await accessLayer.GetResourceCount();
-        (0, vitest_1.expect)(initialCount.detail).toEqual(20000);
+        expect(initialCount.detail).toEqual(20000);
         // Create Record -------------------------------------------------------------------------------------
         const userResourceType = {
             name: `user`,
@@ -96,9 +91,9 @@ const sort = (a, b) => {
         };
         const userResourceTypeCreateRecord = await accessLayer.CreateResource(userResourceOptions, userResourceType);
         const matchCreateResource = {
-            operation: commonTypes_js_1.eOperations.CreateResource,
+            operation: eOperations.CreateResource,
             options: userResourceOptions,
-            status: http_status_codes_1.StatusCodes.CREATED,
+            status: StatusCodes.CREATED,
             detail: {
                 dbaction: 1,
                 dbactionuser,
@@ -109,25 +104,25 @@ const sort = (a, b) => {
             }
         };
         const createdResource = userResourceTypeCreateRecord.detail;
-        (0, vitest_1.expect)(userResourceTypeCreateRecord).toMatchObject(matchCreateResource);
-        (0, vitest_1.expect)(createdResource.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(createdResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(userResourceTypeCreateRecord).toMatchObject(matchCreateResource);
+        expect(createdResource.oid).not.toBeNull();
+        expect(new Date(createdResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Get Resource Count -------------------------------------------------------------------------------------
         const count = await accessLayer.GetResourceCount();
-        (0, vitest_1.expect)(count.detail).toEqual(20001);
+        expect(count.detail).toEqual(20001);
         const matchGetResourceCount = {
-            operation: commonTypes_js_1.eOperations.GetResourceCount,
+            operation: eOperations.GetResourceCount,
             options: {},
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: 20001
         };
-        (0, vitest_1.expect)(count).toMatchObject(matchGetResourceCount);
+        expect(count).toMatchObject(matchGetResourceCount);
         // Get Record -------------------------------------------------------------------------------------
         const getRecord1 = await accessLayer.GetResource(userResourceOptions);
         const matchGetResource = {
-            operation: commonTypes_js_1.eOperations.GetResource,
+            operation: eOperations.GetResource,
             options: userResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: {
                 dbaction: 1,
                 dbactionuser,
@@ -138,9 +133,9 @@ const sort = (a, b) => {
             }
         };
         const getResource = getRecord1.detail;
-        (0, vitest_1.expect)(getRecord1).toMatchObject(matchGetResource);
-        (0, vitest_1.expect)(getResource.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(getResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(getRecord1).toMatchObject(matchGetResource);
+        expect(getResource.oid).not.toBeNull();
+        expect(new Date(getResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Update Record -------------------------------------------------------------------------------------
         const updateUserResource = {
             name: userResourceType.name,
@@ -149,9 +144,9 @@ const sort = (a, b) => {
         };
         const userResourceTypeUpdateRecord = await accessLayer.UpdateResource(userResourceOptions, updateUserResource);
         const matchUpdateResource = {
-            operation: commonTypes_js_1.eOperations.UpdateResource,
+            operation: eOperations.UpdateResource,
             options: userResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: {
                 dbaction: 2,
                 dbactionuser,
@@ -162,9 +157,9 @@ const sort = (a, b) => {
             }
         };
         const updatedResource = userResourceTypeUpdateRecord.detail;
-        (0, vitest_1.expect)(userResourceTypeUpdateRecord).toMatchObject(matchUpdateResource);
-        (0, vitest_1.expect)(updatedResource.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(updatedResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(userResourceTypeUpdateRecord).toMatchObject(matchUpdateResource);
+        expect(updatedResource.oid).not.toBeNull();
+        expect(new Date(updatedResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Patch Record -------------------------------------------------------------------------------------
         const patchUserResource = {
             name: userResourceType.name,
@@ -172,9 +167,9 @@ const sort = (a, b) => {
         };
         const patchResourceRecord = await accessLayer.PatchResource(userResourceOptions, patchUserResource);
         const matchPatchResource = {
-            operation: commonTypes_js_1.eOperations.PatchResource,
+            operation: eOperations.PatchResource,
             options: userResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: {
                 dbaction: 2,
                 dbactionuser,
@@ -189,15 +184,15 @@ const sort = (a, b) => {
             }
         };
         const patchedResource = patchResourceRecord.detail;
-        (0, vitest_1.expect)(patchResourceRecord).toMatchObject(matchPatchResource);
-        (0, vitest_1.expect)(patchedResource.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(patchedResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(patchResourceRecord).toMatchObject(matchPatchResource);
+        expect(patchedResource.oid).not.toBeNull();
+        expect(new Date(patchedResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Delete Record -------------------------------------------------------------------------------------
         const userResourceTypeDeleteRecord = await accessLayer.DeleteResource(userResourceOptions);
         const matchDeleteResource = {
-            operation: commonTypes_js_1.eOperations.DeleteResource,
+            operation: eOperations.DeleteResource,
             options: userResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: {
                 dbaction: 3,
                 dbactionuser,
@@ -212,32 +207,32 @@ const sort = (a, b) => {
             }
         };
         const deletedResource = userResourceTypeDeleteRecord.detail;
-        (0, vitest_1.expect)(userResourceTypeDeleteRecord).toMatchObject(matchDeleteResource);
-        (0, vitest_1.expect)(deletedResource.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(deletedResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(userResourceTypeDeleteRecord).toMatchObject(matchDeleteResource);
+        expect(deletedResource.oid).not.toBeNull();
+        expect(new Date(deletedResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Get a Deleted Record -------------------------------------------------------------------------------------
         const getDeletedRecord = await accessLayer.GetResource(userResourceOptions);
         const matchNotFoundResource = {
-            operation: commonTypes_js_1.eOperations.GetResource,
+            operation: eOperations.GetResource,
             options: userResourceOptions,
-            status: http_status_codes_1.StatusCodes.NOT_FOUND,
+            status: StatusCodes.NOT_FOUND,
             detail: null,
             error: {
-                operation: commonTypes_js_1.eOperations.GetResource,
-                status: http_status_codes_1.StatusCodes.NOT_FOUND
+                operation: eOperations.GetResource,
+                status: StatusCodes.NOT_FOUND
             }
         };
-        (0, vitest_1.expect)(getDeletedRecord).toMatchObject(matchNotFoundResource);
-        (0, vitest_1.expect)(getDeletedRecord.error?.errorMessage).toMatch(/\(current version\) not found/);
+        expect(getDeletedRecord).toMatchObject(matchNotFoundResource);
+        expect(getDeletedRecord.error?.errorMessage).toMatch(/\(current version\) not found/);
         // Get Resource Count -------------------------------------------------------------------------------------
         const resourceCountPostDelete = await accessLayer.GetResourceCount();
         const matchResourceCountPostDelete = {
-            operation: commonTypes_js_1.eOperations.GetResourceCount,
+            operation: eOperations.GetResourceCount,
             options: {},
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: 20000
         };
-        (0, vitest_1.expect)(resourceCountPostDelete).toMatchObject(matchResourceCountPostDelete);
+        expect(resourceCountPostDelete).toMatchObject(matchResourceCountPostDelete);
         // Get Resources using filter -------------------------------------------------------------------------------------
         const resources = await accessLayer.GetResources({
             filters: {
@@ -245,10 +240,10 @@ const sort = (a, b) => {
                 limit: '10',
             }
         });
-        (0, vitest_1.expect)(resources.detail.length).toEqual(10);
+        expect(resources.detail.length).toEqual(10);
     }, 120000);
-    (0, vitest_1.test)('Testing Database Entity create, update, patch, read and delete', async () => {
-        vitest_1.expect.assertions(30);
+    test('Testing Database Entity create, update, patch, read and delete', async () => {
+        expect.assertions(30);
         const userResourceType = {
             name: 'user-t2',
             notes: 'user-t2 notes',
@@ -262,11 +257,11 @@ const sort = (a, b) => {
         };
         const userResourceTypeCreateRecord = await accessLayer.CreateResource(userResourceOptions, userResourceType);
         const matchCreateResource = {
-            operation: commonTypes_js_1.eOperations.CreateResource,
+            operation: eOperations.CreateResource,
             options: userResourceOptions,
-            status: http_status_codes_1.StatusCodes.CREATED,
+            status: StatusCodes.CREATED,
             detail: {
-                dbaction: stsutils_1.edbaction.created,
+                dbaction: edbaction.created,
                 dbactionuser,
                 resdesc: userResourceType,
                 resname: userResourceType.name,
@@ -275,9 +270,9 @@ const sort = (a, b) => {
             }
         };
         const createdResource = userResourceTypeCreateRecord.detail;
-        (0, vitest_1.expect)(userResourceTypeCreateRecord).toMatchObject(matchCreateResource);
-        (0, vitest_1.expect)(createdResource.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(createdResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(userResourceTypeCreateRecord).toMatchObject(matchCreateResource);
+        expect(createdResource.oid).not.toBeNull();
+        expect(new Date(createdResource.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         const resOid = createdResource.oid;
         const userEntity01 = {
             userId: 'user01',
@@ -295,12 +290,12 @@ const sort = (a, b) => {
         // Create Record -------------------------------------------------------------------------------------
         const entityUser01CreateRecord = await accessLayer.CreateEntity(entityResourceOptions, userEntity01);
         const matchCreateEntity = {
-            operation: commonTypes_js_1.eOperations.CreateEntity,
+            operation: eOperations.CreateEntity,
             options: entityResourceOptions,
-            status: http_status_codes_1.StatusCodes.CREATED,
+            status: StatusCodes.CREATED,
             detail: {
                 resourceoid: resOid,
-                dbaction: stsutils_1.edbaction.created,
+                dbaction: edbaction.created,
                 dbactionuser,
                 entvalue: userEntity01,
                 entname: userEntity01.userId,
@@ -309,27 +304,27 @@ const sort = (a, b) => {
             }
         };
         const createdEntity = entityUser01CreateRecord.detail;
-        (0, vitest_1.expect)(entityUser01CreateRecord).toMatchObject(matchCreateEntity);
-        (0, vitest_1.expect)(createdEntity.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(createdEntity.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(entityUser01CreateRecord).toMatchObject(matchCreateEntity);
+        expect(createdEntity.oid).not.toBeNull();
+        expect(new Date(createdEntity.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Get Entity Count Post Create -------------------------------------------------------------------------------------
         const entityCountPostCreate = await accessLayer.GetEntityCount(entityResourceOptions);
         const matchEntityCountPostCreate = {
-            operation: commonTypes_js_1.eOperations.GetEntityCount,
+            operation: eOperations.GetEntityCount,
             options: entityResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: 1
         };
-        (0, vitest_1.expect)(entityCountPostCreate).toMatchObject(matchEntityCountPostCreate);
+        expect(entityCountPostCreate).toMatchObject(matchEntityCountPostCreate);
         // Get Record -------------------------------------------------------------------------------------
         const getRecord1 = await accessLayer.GetEntity(entityResourceOptions);
         const matchGetEntity = {
-            operation: commonTypes_js_1.eOperations.GetEntity,
+            operation: eOperations.GetEntity,
             options: entityResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: {
                 resourceoid: resOid,
-                dbaction: stsutils_1.edbaction.created,
+                dbaction: edbaction.created,
                 dbactionuser,
                 entvalue: userEntity01,
                 entname: userEntity01.userId,
@@ -338,9 +333,9 @@ const sort = (a, b) => {
             }
         };
         const getEntityRecord = getRecord1.detail;
-        (0, vitest_1.expect)(getRecord1).toMatchObject(matchGetEntity);
-        (0, vitest_1.expect)(getEntityRecord.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(getEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(getRecord1).toMatchObject(matchGetEntity);
+        expect(getEntityRecord.oid).not.toBeNull();
+        expect(new Date(getEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Update Record -------------------------------------------------------------------------------------
         const updateEntityResource = {
             userId: userEntity01.userId,
@@ -350,12 +345,12 @@ const sort = (a, b) => {
         };
         const userEntity01UpdateRecord = await accessLayer.UpdateEntity(entityResourceOptions, updateEntityResource);
         const matchUpdateEntity = {
-            operation: commonTypes_js_1.eOperations.UpdateEntity,
+            operation: eOperations.UpdateEntity,
             options: entityResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: {
                 resourceoid: resOid,
-                dbaction: stsutils_1.edbaction.updated,
+                dbaction: edbaction.updated,
                 dbactionuser,
                 entvalue: updateEntityResource,
                 entname: updateEntityResource.userId,
@@ -364,9 +359,9 @@ const sort = (a, b) => {
             }
         };
         const updateEntityRecord = userEntity01UpdateRecord.detail;
-        (0, vitest_1.expect)(userEntity01UpdateRecord).toMatchObject(matchUpdateEntity);
-        (0, vitest_1.expect)(updateEntityRecord.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(updateEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(userEntity01UpdateRecord).toMatchObject(matchUpdateEntity);
+        expect(updateEntityRecord.oid).not.toBeNull();
+        expect(new Date(updateEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Patch Record -------------------------------------------------------------------------------------
         const patchEntityResource = {
             userId: userEntity01.userId,
@@ -374,12 +369,12 @@ const sort = (a, b) => {
         };
         const userEntity01PatchRecord = await accessLayer.PatchEntity(entityResourceOptions, patchEntityResource);
         const matchPatchedEntity = {
-            operation: commonTypes_js_1.eOperations.PatchEntity,
+            operation: eOperations.PatchEntity,
             options: entityResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: {
                 resourceoid: resOid,
-                dbaction: stsutils_1.edbaction.updated,
+                dbaction: edbaction.updated,
                 dbactionuser,
                 entvalue: { ...updateEntityResource, ...patchEntityResource },
                 entname: patchEntityResource.userId,
@@ -388,18 +383,18 @@ const sort = (a, b) => {
             }
         };
         const patchedEntityRecord = userEntity01PatchRecord.detail;
-        (0, vitest_1.expect)(userEntity01PatchRecord).toMatchObject(matchPatchedEntity);
-        (0, vitest_1.expect)(patchedEntityRecord.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(patchedEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(userEntity01PatchRecord).toMatchObject(matchPatchedEntity);
+        expect(patchedEntityRecord.oid).not.toBeNull();
+        expect(new Date(patchedEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Delete Record -------------------------------------------------------------------------------------
         const userEntity01DeleteRecord = await accessLayer.DeleteEntity(entityResourceOptions);
         const matchDeletedEntity = {
-            operation: commonTypes_js_1.eOperations.DeleteEntity,
+            operation: eOperations.DeleteEntity,
             options: entityResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: {
                 resourceoid: resOid,
-                dbaction: stsutils_1.edbaction.deleted,
+                dbaction: edbaction.deleted,
                 dbactionuser,
                 entvalue: { ...updateEntityResource, ...patchEntityResource },
                 entname: patchEntityResource.userId,
@@ -408,32 +403,32 @@ const sort = (a, b) => {
             }
         };
         const deletedEntityRecord = userEntity01DeleteRecord.detail;
-        (0, vitest_1.expect)(userEntity01DeleteRecord).toMatchObject(matchDeletedEntity);
-        (0, vitest_1.expect)(deletedEntityRecord.oid).not.toBeNull();
-        (0, vitest_1.expect)(new Date(deletedEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+        expect(userEntity01DeleteRecord).toMatchObject(matchDeletedEntity);
+        expect(deletedEntityRecord.oid).not.toBeNull();
+        expect(new Date(deletedEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         // Get a Deleted Record -------------------------------------------------------------------------------------
         const getDeleted = await accessLayer.GetEntity(entityResourceOptions);
         const matchGetDeletedEntity = {
-            operation: commonTypes_js_1.eOperations.GetEntity,
+            operation: eOperations.GetEntity,
             options: entityResourceOptions,
-            status: http_status_codes_1.StatusCodes.NOT_FOUND,
+            status: StatusCodes.NOT_FOUND,
             detail: null,
             error: {
-                operation: commonTypes_js_1.eOperations.GetEntity,
-                status: http_status_codes_1.StatusCodes.NOT_FOUND
+                operation: eOperations.GetEntity,
+                status: StatusCodes.NOT_FOUND
             }
         };
-        (0, vitest_1.expect)(getDeleted).toMatchObject(matchGetDeletedEntity);
-        (0, vitest_1.expect)(getDeleted.error?.errorMessage).toMatch(/\(current version\) not found/);
+        expect(getDeleted).toMatchObject(matchGetDeletedEntity);
+        expect(getDeleted.error?.errorMessage).toMatch(/\(current version\) not found/);
         // Get Entity Count Post Delete -------------------------------------------------------------------------------------
         const entityCountPostDelete = await accessLayer.GetEntityCount(entityResourceOptions);
         const matchEntityCountPostDelete = {
-            operation: commonTypes_js_1.eOperations.GetEntityCount,
+            operation: eOperations.GetEntityCount,
             options: entityResourceOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: 0
         };
-        (0, vitest_1.expect)(entityCountPostDelete).toMatchObject(matchEntityCountPostDelete);
+        expect(entityCountPostDelete).toMatchObject(matchEntityCountPostDelete);
         // Create Additional Entities -------------------------------------------------------------------------------------
         const expDetail = [];
         const createCount = 2;
@@ -454,12 +449,12 @@ const sort = (a, b) => {
             const entityCreateRecord = await accessLayer.CreateEntity(entityResourceOptions, userEntity);
             expDetail.push(entityCreateRecord.detail);
             const matchCreateEntity = {
-                operation: commonTypes_js_1.eOperations.CreateEntity,
+                operation: eOperations.CreateEntity,
                 options: entityResourceOptions,
-                status: http_status_codes_1.StatusCodes.CREATED,
+                status: StatusCodes.CREATED,
                 detail: {
                     resourceoid: resOid,
-                    dbaction: stsutils_1.edbaction.created,
+                    dbaction: edbaction.created,
                     dbactionuser,
                     entvalue: userEntity,
                     entname: userEntity.userId,
@@ -468,9 +463,9 @@ const sort = (a, b) => {
                 }
             };
             const createdEntityRecord = entityCreateRecord.detail;
-            (0, vitest_1.expect)(entityCreateRecord).toMatchObject(matchCreateEntity);
-            (0, vitest_1.expect)(createdEntityRecord.oid).not.toBeNull();
-            (0, vitest_1.expect)(new Date(createdEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+            expect(entityCreateRecord).toMatchObject(matchCreateEntity);
+            expect(createdEntityRecord.oid).not.toBeNull();
+            expect(new Date(createdEntityRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
         }
         // Get Entities (using filters) -------------------------------------------------------------------------------------
         const entities = await accessLayer.GetEntities({
@@ -479,7 +474,7 @@ const sort = (a, b) => {
                 filter: '%'
             }
         });
-        (0, vitest_1.expect)(entities.detail).toMatchObject(expDetail);
+        expect(entities.detail).toMatchObject(expDetail);
         // Get Entity Count Post Delete -------------------------------------------------------------------------------------
         const entityCountOptions = {
             filters: {
@@ -488,12 +483,12 @@ const sort = (a, b) => {
         };
         const entityCountPostMultiCreate = await accessLayer.GetEntityCount(entityCountOptions);
         const matchEntityCountPostMultiCreate = {
-            operation: commonTypes_js_1.eOperations.GetEntityCount,
+            operation: eOperations.GetEntityCount,
             options: entityCountOptions,
-            status: http_status_codes_1.StatusCodes.OK,
+            status: StatusCodes.OK,
             detail: createCount
         };
-        (0, vitest_1.expect)(entityCountPostMultiCreate).toMatchObject(matchEntityCountPostMultiCreate);
+        expect(entityCountPostMultiCreate).toMatchObject(matchEntityCountPostMultiCreate);
     }, 120000);
     /*
     test('Testing Database Resource create and patch', async () => {
@@ -1106,10 +1101,10 @@ const sort = (a, b) => {
         });
     }, 120000);
     */
-    (0, vitest_1.test)('Testing Database Resource Batch Create', async () => {
+    test('Testing Database Resource Batch Create', async () => {
         const createStart = 100;
         const createNum = 60;
-        vitest_1.expect.assertions(180);
+        expect.assertions(180);
         for (let i = createStart; i < createStart + createNum; i++) {
             const userResourceType = {
                 name: `user_patch_test_${i}`,
@@ -1123,27 +1118,27 @@ const sort = (a, b) => {
                 }
             }, userResourceType);
             const checkObject = {
-                status: http_status_codes_1.StatusCodes.CREATED,
+                status: StatusCodes.CREATED,
                 detail: {
                     resname: userResourceType.name,
                     resdesc: userResourceType,
                     vnum: '1',
                     validto: null,
-                    dbaction: stsutils_1.edbaction.created,
+                    dbaction: edbaction.created,
                     dbactionuser
                 }
             };
             const createdResourceRecord = userResourceTypeCreateRecord.detail;
             finalResults[createdResourceRecord.resname] = createdResourceRecord;
-            (0, vitest_1.expect)(userResourceTypeCreateRecord).toMatchObject(checkObject);
-            (0, vitest_1.expect)(new Date(createdResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
-            (0, vitest_1.expect)(parseInt(createdResourceRecord.oid)).toBeGreaterThan(0);
+            expect(userResourceTypeCreateRecord).toMatchObject(checkObject);
+            expect(new Date(createdResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+            expect(parseInt(createdResourceRecord.oid)).toBeGreaterThan(0);
         }
     }, 120000);
-    (0, vitest_1.test)('Testing Database Resource Batch Create using Update', async () => {
+    test('Testing Database Resource Batch Create using Update', async () => {
         const updateStart = 100;
         const updateNum = 5;
-        vitest_1.expect.assertions(15);
+        expect.assertions(15);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = updateStart; i < updateStart + updateNum; i++) {
@@ -1164,16 +1159,16 @@ const sort = (a, b) => {
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
-                status: http_status_codes_1.StatusCodes.CREATED,
+                status: StatusCodes.CREATED,
                 detail: {
                     resname: name,
                     resdesc: userResourceTypePatch,
                     vnum: "1",
                     validto: null,
-                    dbaction: stsutils_1.edbaction.created,
+                    dbaction: edbaction.created,
                     dbactionuser
                 },
-                operation: commonTypes_js_1.eOperations.UpdateResources,
+                operation: eOperations.UpdateResources,
                 options: {}
             };
             testRecords.push(testObject);
@@ -1184,18 +1179,18 @@ const sort = (a, b) => {
         testRecords.sort(sort);
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
-                (0, vitest_1.expect)(retVal[i]).toMatchObject(testRecords[i]);
+                expect(retVal[i]).toMatchObject(testRecords[i]);
                 const updatedResourceRecord = retVal[i].detail;
                 finalResults[updatedResourceRecord.resname] = updatedResourceRecord;
-                (0, vitest_1.expect)(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
-                (0, vitest_1.expect)(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
+                expect(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+                expect(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    (0, vitest_1.test)('Testing Database Resource Batch Update', async () => {
+    test('Testing Database Resource Batch Update', async () => {
         const updateStart = 100;
         const updateNum = 5;
-        vitest_1.expect.assertions(15);
+        expect.assertions(15);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = updateStart; i < updateStart + updateNum; i++) {
@@ -1216,16 +1211,16 @@ const sort = (a, b) => {
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
-                status: http_status_codes_1.StatusCodes.OK,
+                status: StatusCodes.OK,
                 detail: {
                     resname: name,
                     resdesc: userResourceTypePatch,
                     vnum: "2",
                     validto: null,
-                    dbaction: stsutils_1.edbaction.updated,
+                    dbaction: edbaction.updated,
                     dbactionuser
                 },
-                operation: commonTypes_js_1.eOperations.UpdateResources,
+                operation: eOperations.UpdateResources,
                 options: {}
             };
             testRecords.push(testObject);
@@ -1236,19 +1231,19 @@ const sort = (a, b) => {
         testRecords.sort(sort);
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
-                (0, vitest_1.expect)(retVal[i]).toMatchObject(testRecords[i]);
+                expect(retVal[i]).toMatchObject(testRecords[i]);
                 const updatedResourceRecord = retVal[i].detail;
                 finalResults[updatedResourceRecord.resname] = updatedResourceRecord;
-                (0, vitest_1.expect)(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
-                (0, vitest_1.expect)(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
+                expect(new Date(updatedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+                expect(parseInt(updatedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    (0, vitest_1.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;
-        vitest_1.expect.assertions(6);
+        expect.assertions(6);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = updateErrorStart; i < updateErrorStart + updateErrorNum; i++) {
@@ -1274,22 +1269,22 @@ const sort = (a, b) => {
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === updateErrorIndex) {
                 const testObject = {
-                    status: http_status_codes_1.StatusCodes.NOT_FOUND,
+                    status: StatusCodes.NOT_FOUND,
                     detail: null,
-                    operation: commonTypes_js_1.eOperations.GetResource,
+                    operation: eOperations.GetResource,
                     options: {},
                     error: {
-                        operation: commonTypes_js_1.eOperations.GetResource,
-                        status: http_status_codes_1.StatusCodes.NOT_FOUND
+                        operation: eOperations.GetResource,
+                        status: StatusCodes.NOT_FOUND
                     }
                 };
                 testRecords.push(testObject);
             }
             else {
                 const testObject = {
-                    status: http_status_codes_1.StatusCodes.OK,
+                    status: StatusCodes.OK,
                     detail: null,
-                    operation: commonTypes_js_1.eOperations.UpdateResources,
+                    operation: eOperations.UpdateResources,
                     options: {}
                 };
                 testRecords.push(testObject);
@@ -1301,12 +1296,12 @@ const sort = (a, b) => {
         testRecords.sort(sort);
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
-                (0, vitest_1.expect)(retVal[i]).toMatchObject(testRecords[i]);
+                expect(retVal[i]).toMatchObject(testRecords[i]);
                 if (retVal[i].error) {
                     const updatedResourceRecordError = retVal[i].error;
                     const resName = retVal[i].options.filters.resname;
                     finalResults[resName] = updatedResourceRecordError;
-                    (0, vitest_1.expect)(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
+                    expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
                     const resName = retVal[i].options.filters.resname;
@@ -1316,10 +1311,10 @@ const sort = (a, b) => {
             }
         }
     }, 120000);
-    (0, vitest_1.test)('Testing Database Resource Batch Patch', async () => {
+    test('Testing Database Resource Batch Patch', async () => {
         const patchStart = 120;
         const patchNum = 5;
-        vitest_1.expect.assertions(15);
+        expect.assertions(15);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = patchStart; i < patchStart + patchNum; i++) {
@@ -1344,16 +1339,16 @@ const sort = (a, b) => {
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
-                status: http_status_codes_1.StatusCodes.OK,
+                status: StatusCodes.OK,
                 detail: {
                     resname: name,
                     resdesc: userResourceTypePostPatch,
                     vnum: "2",
                     validto: null,
-                    dbaction: stsutils_1.edbaction.updated,
+                    dbaction: edbaction.updated,
                     dbactionuser
                 },
-                operation: commonTypes_js_1.eOperations.PatchResources,
+                operation: eOperations.PatchResources,
                 options: {}
             };
             testRecords.push(testObject);
@@ -1364,19 +1359,19 @@ const sort = (a, b) => {
         testRecords.sort(sort);
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
-                (0, vitest_1.expect)(retVal[i]).toMatchObject(testRecords[i]);
+                expect(retVal[i]).toMatchObject(testRecords[i]);
                 const patchedResourceRecord = retVal[i].detail;
                 finalResults[patchedResourceRecord.resname] = patchedResourceRecord;
-                (0, vitest_1.expect)(new Date(patchedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
-                (0, vitest_1.expect)(parseInt(patchedResourceRecord.oid)).toBeGreaterThan(0);
+                expect(new Date(patchedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+                expect(parseInt(patchedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    (0, vitest_1.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;
-        vitest_1.expect.assertions(6);
+        expect.assertions(6);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = patchErrorStart; i < patchErrorStart + patchErrorNum; i++) {
@@ -1401,22 +1396,22 @@ const sort = (a, b) => {
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === patchErrorIndex) {
                 const testObject = {
-                    status: http_status_codes_1.StatusCodes.NOT_FOUND,
+                    status: StatusCodes.NOT_FOUND,
                     detail: null,
-                    operation: commonTypes_js_1.eOperations.GetResource,
+                    operation: eOperations.GetResource,
                     options: {},
                     error: {
-                        operation: commonTypes_js_1.eOperations.GetResource,
-                        status: http_status_codes_1.StatusCodes.NOT_FOUND
+                        operation: eOperations.GetResource,
+                        status: StatusCodes.NOT_FOUND
                     }
                 };
                 testRecords.push(testObject);
             }
             else {
                 const testObject = {
-                    status: http_status_codes_1.StatusCodes.OK,
+                    status: StatusCodes.OK,
                     detail: null,
-                    operation: commonTypes_js_1.eOperations.PatchResources,
+                    operation: eOperations.PatchResources,
                     options: {}
                 };
                 testRecords.push(testObject);
@@ -1428,12 +1423,12 @@ const sort = (a, b) => {
         testRecords.sort(sort);
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
-                (0, vitest_1.expect)(retVal[i]).toMatchObject(testRecords[i]);
+                expect(retVal[i]).toMatchObject(testRecords[i]);
                 if (retVal[i].error) {
                     const patchedResourceRecordError = retVal[i].error;
                     const resName = retVal[i].options.filters.resname;
                     finalResults[resName] = patchedResourceRecordError;
-                    (0, vitest_1.expect)(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
+                    expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
                     const resName = retVal[i].options.filters.resname;
@@ -1443,10 +1438,10 @@ const sort = (a, b) => {
             }
         }
     }, 120000);
-    (0, vitest_1.test)('Testing Database Resource Batch Delete', async () => {
+    test('Testing Database Resource Batch Delete', async () => {
         const deleteStart = 140;
         const deleteNum = 5;
-        vitest_1.expect.assertions(15);
+        expect.assertions(15);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = deleteStart; i < deleteStart + deleteNum; i++) {
@@ -1470,16 +1465,16 @@ const sort = (a, b) => {
             };
             resourceParameterPatchRecord.push(resourceParameterRecord);
             const testObject = {
-                status: http_status_codes_1.StatusCodes.OK,
+                status: StatusCodes.OK,
                 detail: {
                     resname: name,
                     resdesc: userOriginalResourceType,
                     vnum: "2",
                     validto: null,
-                    dbaction: stsutils_1.edbaction.deleted,
+                    dbaction: edbaction.deleted,
                     dbactionuser
                 },
-                operation: commonTypes_js_1.eOperations.DeleteResources,
+                operation: eOperations.DeleteResources,
                 options: {}
             };
             testRecords.push(testObject);
@@ -1490,19 +1485,19 @@ const sort = (a, b) => {
         testRecords.sort(sort);
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
-                (0, vitest_1.expect)(retVal[i]).toMatchObject(testRecords[i]);
+                expect(retVal[i]).toMatchObject(testRecords[i]);
                 const deletedResourceRecord = retVal[i].detail;
                 finalResults[deletedResourceRecord.resname] = deletedResourceRecord;
-                (0, vitest_1.expect)(new Date(deletedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
-                (0, vitest_1.expect)(parseInt(deletedResourceRecord.oid)).toBeGreaterThan(0);
+                expect(new Date(deletedResourceRecord.validfrom).getTime()).toBeLessThanOrEqual(new Date().getTime());
+                expect(parseInt(deletedResourceRecord.oid)).toBeGreaterThan(0);
             }
         }
     }, 120000);
-    (0, vitest_1.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;
-        vitest_1.expect.assertions(6);
+        expect.assertions(6);
         const resourceParameterPatchRecord = [];
         const testRecords = [];
         for (let i = deleteErrorStart; i < deleteErrorStart + deleteErrorNum; i++) {
@@ -1525,22 +1520,22 @@ const sort = (a, b) => {
             resourceParameterPatchRecord.push(resourceParameterRecord);
             if (i === deleteErrorIndex) {
                 const testObject = {
-                    status: http_status_codes_1.StatusCodes.NOT_FOUND,
+                    status: StatusCodes.NOT_FOUND,
                     detail: null,
-                    operation: commonTypes_js_1.eOperations.GetResource,
+                    operation: eOperations.GetResource,
                     options: {},
                     error: {
-                        operation: commonTypes_js_1.eOperations.GetResource,
-                        status: http_status_codes_1.StatusCodes.NOT_FOUND
+                        operation: eOperations.GetResource,
+                        status: StatusCodes.NOT_FOUND
                     }
                 };
                 testRecords.push(testObject);
             }
             else {
                 const testObject = {
-                    status: http_status_codes_1.StatusCodes.OK,
+                    status: StatusCodes.OK,
                     detail: null,
-                    operation: commonTypes_js_1.eOperations.DeleteResources,
+                    operation: eOperations.DeleteResources,
                     options: {}
                 };
                 testRecords.push(testObject);
@@ -1552,12 +1547,12 @@ const sort = (a, b) => {
         testRecords.sort(sort);
         if (retVal.length === testRecords.length) {
             for (let i = 0; i < retVal.length; i++) {
-                (0, vitest_1.expect)(retVal[i]).toMatchObject(testRecords[i]);
+                expect(retVal[i]).toMatchObject(testRecords[i]);
                 if (retVal[i].error) {
                     const deletedResourceRecordError = retVal[i].error;
                     const resName = retVal[i].options.filters.resname;
                     finalResults[resName] = deletedResourceRecordError;
-                    (0, vitest_1.expect)(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
+                    expect(retVal[i].error?.errorMessage).toMatch(/\(current version\) not found/);
                 }
                 else {
                     const resName = retVal[i].options.filters.resname;
@@ -1567,8 +1562,8 @@ const sort = (a, b) => {
             }
         }
     }, 120000);
-    (0, vitest_1.test)('Get All user_patch_test_ Resources', async () => {
-        vitest_1.expect.assertions(51);
+    test('Get All user_patch_test_ Resources', async () => {
+        expect.assertions(51);
         // All Records
         const AllRecords = await accessLayer.GetResources({
             filters: {
@@ -1576,14 +1571,14 @@ const sort = (a, b) => {
                 limit: '50'
             }
         });
-        (0, vitest_1.expect)(AllRecords.detail.length).toEqual(50);
+        expect(AllRecords.detail.length).toEqual(50);
         AllRecords.detail.forEach(u => {
             const compareObject = finalResults[u.resname];
             if (compareObject) {
-                (0, vitest_1.expect)(u).toMatchObject(compareObject);
+                expect(u).toMatchObject(compareObject);
             }
         });
-        console.log(chalk_1.default.cyan(`Resource List`));
+        console.log(chalk.cyan(`Resource List`));
         // Output formatted table
         const columns = [
             {
@@ -1621,9 +1616,9 @@ const sort = (a, b) => {
             console.log(detail);
         });
     });
-    (0, vitest_1.afterAll)(async () => {
+    afterAll(async () => {
         await accessLayer.EndDatabase();
-        await (0, stsutils_1.JestSleep)();
+        await JestSleep();
         await postgresContainer.stop();
     }, 5000);
 });