@nsshunt/stsappframework 3.1.136 → 3.1.138

package/src/fhir/dalFhirManagerPGRes.test.ts

@@ -0,0 +1,42 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import { beforeAll, afterAll, test, describe, expect } from 'vitest';
+
+import { accessLayerType, IPGAccessLayerOptions, SYSTEM_USER_ID } from '@nsshunt/stsdatamanagement'
+
+import { DALFhirManagerPGRes } from './dalFhirManagerPGRes'
+
+import { IPerson } from './STSFhirTypes'
+
+import { TestHelpers } from './dalFhirTestHelpers'
+
+describe("Test hl7 fhir resource data access layer - PGRes", () =>
+{
+    let testHelpers: TestHelpers;
+
+    beforeAll(async () => 
+    {
+        testHelpers = new TestHelpers();
+        await testHelpers.StartDatabase();
+    }, 30000);
+
+    test('Testing Person', async () => {
+        expect.assertions(6);
+
+        const personManager = new DALFhirManagerPGRes<IPerson>({
+            accessLayerType: accessLayerType.postgresql,
+            accessLayerOptions: {
+                logger: testHelpers.logger,
+                usedefaultdb: false
+            } as IPGAccessLayerOptions,
+            resourceName: 'STSFhirPerson',
+            dbactionuser: SYSTEM_USER_ID
+        });
+
+        await testHelpers.TestFhirPerson(personManager);
+    }, 30000);
+
+    afterAll(async () =>
+    {
+        await testHelpers.StopDatabase();
+    }, 5000);
+});

package/src/fhir/dalFhirManagerPGRes.ts

@@ -0,0 +1,92 @@
+import { DBAccessLayerManager, IDBAccessLayer, IDBAccessLayerManagerOptions, IDBResource } from '@nsshunt/stsdatamanagement'
+
+import { IDomainResource, IDALFhirDataAccessManager } from './STSFhirTypes'
+
+export interface IFhirManagerPGResOptions extends IDBAccessLayerManagerOptions {
+    resourceName: string
+    dbactionuser: string
+}
+
+export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
+    #options: IFhirManagerPGResOptions;
+    #accessLayer: IDBAccessLayer;
+
+    constructor(options: IFhirManagerPGResOptions) {
+        this.#options = options;
+        this.#accessLayer = new DBAccessLayerManager().CreateAccessLayer({
+            accessLayerType: options.accessLayerType,
+            accessLayerOptions: options.accessLayerOptions
+        });
+    }
+
+    GetResourceType(fhir: Partial<T>): string {
+        return `${this.#options.resourceName}_${(fhir as Partial<IDomainResource>).id}`;
+    }
+
+    async GetFhirResource(fhir: Partial<T>, ecb?: (error: Error) => void): Promise<T | null> {
+        const retVal = await this.#accessLayer.GetResource<T>({
+            filters: {
+                resname: this.GetResourceType(fhir)
+            }
+        });
+        if (retVal.error) {
+            if (ecb) {
+                ecb(retVal.error.error);
+            }
+            return null;
+        } else {
+            return (retVal.detail as IDBResource<T>).resdesc;
+        }
+    }
+
+    async CreateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+        const retVal = await this.#accessLayer.CreateResource<T>({
+            filters: {
+                dbactionuser: this.#options.dbactionuser,
+                resname: this.GetResourceType(fhir)
+            }
+        }, fhir);
+        if (retVal.error) {
+            if (ecb) {
+                ecb(retVal.error.error);
+            }
+            return null;
+        } else {
+            return (retVal.detail as IDBResource<T>).resdesc;
+        }
+    }
+
+    async UpdateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+        const retVal = await this.#accessLayer.UpdateResource<T>({
+            filters: {
+                dbactionuser: this.#options.dbactionuser,
+                resname: this.GetResourceType(fhir)
+            }
+        }, fhir);
+        if (retVal.error) {
+            if (ecb) {
+                ecb(retVal.error.error);
+            }
+            return null;
+        } else {
+            return (retVal.detail as IDBResource<T>).resdesc;
+        }
+    }
+
+    async DeleteFhirResource(fhir: Partial<T>, ecb?: (error: Error) => void): Promise<T | null> {
+        const retVal = await this.#accessLayer.DeleteResource<T>({
+            filters: {
+                dbactionuser: this.#options.dbactionuser,
+                resname: this.GetResourceType(fhir)
+            }
+        });
+        if (retVal.error) {
+            if (ecb) {
+                ecb(retVal.error.error);
+            }
+            return null;
+        } else {
+            return (retVal.detail as IDBResource<T>).resdesc;
+        }
+    }
+}

package/src/fhir/dalFhirManagerPGResEntity.test.ts

@@ -0,0 +1,43 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import { beforeAll, afterAll, test, describe, expect } from 'vitest';
+
+import { accessLayerType, IPGAccessLayerOptions, SYSTEM_USER_ID } from '@nsshunt/stsdatamanagement'
+
+import { DALFhirManagerPGResEntity } from './dalFhirManagerPGResEntity'
+
+import { IPerson } from './STSFhirTypes'
+
+import { TestHelpers } from './dalFhirTestHelpers'
+
+describe("Test hl7 fhir resource data access layer - PGResEntity", () =>
+{
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let testHelpers: TestHelpers;
+
+    beforeAll(async () => 
+    {
+        testHelpers = new TestHelpers();
+        await testHelpers.StartDatabase();
+    }, 30000);
+
+    test('Testing Person', async () => {
+        expect.assertions(6);
+
+        const personManager = new DALFhirManagerPGResEntity<IPerson>({
+            accessLayerType: accessLayerType.postgresql,
+            accessLayerOptions: {
+                logger: testHelpers.logger,
+                usedefaultdb: false
+            } as IPGAccessLayerOptions,
+            resourceName: 'STSFhirPerson',
+            dbactionuser: SYSTEM_USER_ID
+        });
+
+        await testHelpers.TestFhirPerson(personManager);
+    }, 30000);
+
+    afterAll(async () =>
+    {
+        await testHelpers.StopDatabase();
+    }, 5000);
+});

package/src/fhir/dalFhirManagerPGResEntity.ts

@@ -0,0 +1,123 @@
+import { DBAccessLayerManager, IDBAccessLayer, IDBAccessLayerManagerOptions, IDBResource, IDBEntity } from '@nsshunt/stsdatamanagement'
+
+import { IDomainResource, IFHIRResource, IDALFhirDataAccessManager } from './STSFhirTypes'
+
+export interface IFhirManagerPGResEntityOptions extends IDBAccessLayerManagerOptions {
+    resourceName: string
+    dbactionuser: string
+}
+
+export class DALFhirManagerPGResEntity<T> implements IDALFhirDataAccessManager<T> {
+    #options: IFhirManagerPGResEntityOptions;
+    #accessLayer: IDBAccessLayer;
+    #fhirResource: IDBResource<IFHIRResource> | undefined;
+
+    constructor(options: IFhirManagerPGResEntityOptions) {
+        this.#options = options;
+        this.#accessLayer = new DBAccessLayerManager().CreateAccessLayer({
+            accessLayerType: options.accessLayerType,
+            accessLayerOptions: options.accessLayerOptions
+        });
+    }
+
+    #GetSTSFhirBaseResource = async (): Promise<IDBResource<IFHIRResource>> => {
+        if (!this.#fhirResource) {
+            this.#fhirResource = ((await this.#accessLayer.GetResource<IFHIRResource>({
+                filters: {
+                    resname: this.#options.resourceName
+                }
+            })).detail as IDBResource<IFHIRResource>);
+
+            if (!this.#fhirResource) {
+                const fhirResourceType: IFHIRResource = {
+                    name: this.#options.resourceName,
+                    description: `${this.#options.resourceName} description`,
+                    notes: `${this.#options.resourceName} notes`,
+                }
+                this.#fhirResource = ((await this.#accessLayer.CreateResource<IFHIRResource>({
+                    filters: {
+                        dbactionuser: this.#options.dbactionuser,
+                        resname: this.#options.resourceName
+                    }
+                }, fhirResourceType)).detail as IDBResource<IFHIRResource>);
+            }
+        }
+
+        return this.#fhirResource;
+    }
+
+    async GetFhirResource(fhir: Partial<T>, ecb?: (error: Error) => void): Promise<T | null> {
+        const fhirResource = await this.#GetSTSFhirBaseResource();
+        const retVal = await this.#accessLayer.GetEntity<T>({
+            filters: {
+                resname: fhirResource.resname,
+                entname: (fhir as Partial<IDomainResource>).id
+            }
+        });
+        if (retVal.error) {
+            if (ecb) {
+                ecb(retVal.error.error);
+            }
+            return null;
+        } else {
+            return (retVal.detail as IDBEntity<T>).entvalue;
+        }
+    }
+
+    async CreateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+        const fhirResource = await this.#GetSTSFhirBaseResource();
+        const retVal = await this.#accessLayer.CreateEntity<T>({
+            filters: {
+                dbactionuser: this.#options.dbactionuser,
+                resname: fhirResource.resname,
+                entname: (fhir as Partial<IDomainResource>).id
+            }
+        }, fhir);
+        if (retVal.error) {
+            if (ecb) {
+                ecb(retVal.error.error);
+            }
+            return null;
+        } else {
+            return (retVal.detail as IDBEntity<T>).entvalue;
+        }
+    }
+
+    async UpdateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+        const fhirResource = await this.#GetSTSFhirBaseResource();
+        const retVal = await this.#accessLayer.UpdateEntity<T>({
+            filters: {
+                dbactionuser: this.#options.dbactionuser,
+                resname: fhirResource.resname,
+                entname: (fhir as Partial<IDomainResource>).id
+            }
+        }, fhir);
+        if (retVal.error) {
+            if (ecb) {
+                ecb(retVal.error.error);
+            }
+            return null;
+        } else {
+            return (retVal.detail as IDBEntity<T>).entvalue;
+        }
+    }
+
+    async DeleteFhirResource(fhir: Partial<T>, ecb?: (error: Error) => void): Promise<T | null> {
+        const fhirResource = await this.#GetSTSFhirBaseResource();
+        const retVal = await this.#accessLayer.DeleteEntity<T>({
+            filters: {
+                dbactionuser: this.#options.dbactionuser,
+                resname: fhirResource.resname,
+                entname: (fhir as Partial<IDomainResource>).id
+            }
+        });
+        if (retVal.error) {
+            if (ecb) {
+                ecb(retVal.error.error);
+            }
+            return null;
+        } else {
+            return (retVal.detail as IDBEntity<T>).entvalue;
+        }
+    }
+}

package/src/fhir/dalFhirManagerRedisJson.test.ts

@@ -0,0 +1,44 @@
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import { beforeAll, afterAll, test, describe, expect } from 'vitest';
+
+import { DALFhirManagerRedisJson } from './dalFhirManagerRedisJson'
+
+import { IPerson } from './STSFhirTypes'
+
+import { TestHelpers } from './dalFhirTestHelpers'
+
+import { JestSleep } from '@nsshunt/stsutils'
+
+describe.skip("Test hl7 fhir resource data access layer - RedisJson", () =>
+{
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let personManager: DALFhirManagerRedisJson<IPerson>;
+    let testHelpers: TestHelpers;
+
+    beforeAll(async () => 
+    {
+        testHelpers = new TestHelpers();
+        await testHelpers.StartRedis();
+
+        personManager = new DALFhirManagerRedisJson<IPerson>({
+            //const personManager = new DALFhirManagerPGRes<IPerson>({
+            //const personManager = new DALFhirManagerPGResEntity<IPerson>({
+            resourceName: 'STSFhirPerson',
+            redisUrl: testHelpers.ioRedisMessageProcessorUrl
+        });
+        personManager.Start();
+    }, 30000);
+
+    test('Testing Person', async () => {
+        expect.assertions(6);
+
+        await testHelpers.TestFhirPerson(personManager);
+    }, 30000);
+
+    afterAll(async () =>
+    {
+        personManager.Stop();
+        await JestSleep();
+        await testHelpers.StopRedis();
+    }, 5000);
+});

package/src/fhir/dalFhirManagerRedisJson.ts

@@ -0,0 +1,92 @@
+import { IDomainResource, IDALFhirDataAccessManager } from './STSFhirTypes'
+
+import { Redis, RedisOptions } from "ioredis";
+
+export interface IFhirManagerRedisJsonOptions {
+    redisUrl: string
+    resourceName: string
+}
+
+export class DALFhirManagerRedisJson<T> implements IDALFhirDataAccessManager<T> {
+    #options: IFhirManagerRedisJsonOptions;
+    #redisSubscriber: Redis | null = null;
+
+    constructor(options: IFhirManagerRedisJsonOptions) {
+        this.#options = options;
+    }
+
+    Start() {
+        const redisOptions: RedisOptions = {
+            showFriendlyErrorStack: true,
+            maxRetriesPerRequest: 20
+        }
+
+        this.#redisSubscriber = new Redis(this.#options.redisUrl, redisOptions);
+    }
+
+    Stop() {
+        if (this.#redisSubscriber) {
+            this.#redisSubscriber.quit();
+            this.#redisSubscriber.disconnect();
+        }
+    }
+
+    GetResourceType(fhir: Partial<T>): string {
+        return `${this.#options.resourceName}_${(fhir as Partial<IDomainResource>).id}`;
+    }
+
+    async GetFhirResource(fhir: Partial<T>, ecb?: (error: Error) => void): Promise<T | null> {
+        if (this.#redisSubscriber) {
+            const retValRaw = await this.#redisSubscriber?.get(this.GetResourceType(fhir))
+            if (retValRaw) {
+                try {
+                    return JSON.parse(retValRaw) as T;
+                } catch (error: unknown) {
+                    if (ecb) {
+                        ecb(error as Error);
+                    }
+                    return null;
+                }
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+    async CreateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+        const retVal = await this.#redisSubscriber?.set(this.GetResourceType(fhir), JSON.stringify(fhir));
+        if (retVal) {
+            return fhir;
+        } else {
+            return null;
+        }
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+    async UpdateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+        const retVal = await this.#redisSubscriber?.set(this.GetResourceType(fhir), JSON.stringify(fhir));
+        if (retVal) {
+            return fhir;
+        } else {
+            return null;
+        }
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+    async DeleteFhirResource(fhir: Partial<T>, ecb?: (error: Error) => void): Promise<T | null> {
+        const deleteResource = await this.GetFhirResource(fhir);
+        if (deleteResource) {
+            const retVal = await this.#redisSubscriber?.del(this.GetResourceType(fhir));
+            if (retVal) {
+                return deleteResource;
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+}

package/src/fhir/dalFhirTestHelpers.ts

@@ -0,0 +1,163 @@
+import { expect } from 'vitest';
+import { IDALFhirDataAccessManager, INarrative, IPerson } from './STSFhirTypes'
+import { v4 as uuidv4 } from 'uuid';
+
+import chalk from 'chalk';
+
+import { goptions, $ResetOptions } from '@nsshunt/stsconfig'
+
+import { JestSleep, defaultLogger, Sleep } from '@nsshunt/stsutils'
+
+import { DatabaseUtils, DBAccessLayerManager, IDBAccessLayer, accessLayerType, IPGAccessLayerOptions } from '@nsshunt/stsdatamanagement'
+
+import { GenericContainer } from "testcontainers";
+
+import winston from 'winston'
+
+export class TestHelpers {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    #postgresContainer: any;
+    #accessLayer: IDBAccessLayer | null = null;
+    #logger: winston.Logger;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    #ioRedisContainer: any;
+    #ioRedisMessageProcessorUrl = '';
+
+    constructor() {
+        winston.format.combine(
+            winston.format.colorize(),
+            winston.format.simple()
+        );
+    
+        this.#logger = winston.createLogger({
+            level: 'silly',
+            format: winston.format.combine(
+                winston.format.colorize(),
+                winston.format.simple()
+            ),
+            transports: [
+                new winston.transports.Console(),
+            ]});
+    }
+
+    get logger(): winston.Logger {
+        return this.#logger;
+    }
+
+    TestFhirPerson = async (personManager: IDALFhirDataAccessManager<IPerson>) => {
+        expect.assertions(6);
+
+        const id = uuidv4();
+
+        const personRecord: IPerson = {
+            id,
+            _resourceType: 'Person',
+            name: [
+                {
+                    family: 'family',
+                    given: [ 'given' ],
+                    use: 'usual'
+                }
+            ],
+            text: {
+                div: 'New Record',
+                status: 'generated'
+            }
+        };
+
+        const newPerson01 = await personManager.CreateFhirResource(personRecord);
+        expect(newPerson01).toMatchObject(personRecord);
+
+        (personRecord.text as INarrative).div = 'user01 updated at ' + new Date().toString();
+        const updatedPerson01 = await personManager.UpdateFhirResource(personRecord);
+        expect(updatedPerson01).toMatchObject(personRecord);
+
+        const getPerson01 = await personManager.GetFhirResource({id})
+        expect(getPerson01).toMatchObject(personRecord);
+
+        const getPerson02 = await personManager.GetFhirResource({id:'willnotfind'})
+        expect(getPerson02).toBeNull();
+
+        const deletePerson01 = await personManager.DeleteFhirResource({id})
+        expect(deletePerson01).toMatchObject(personRecord);
+
+        const getPerson01AfterDelete = await personManager.GetFhirResource({id})
+        expect(getPerson01AfterDelete).toBeNull();
+    }
+
+    StartDatabase = async() => {
+        this.#postgresContainer = await new GenericContainer("postgres")
+            .withExposedPorts(5432)
+            .withEnvironment({
+                POSTGRES_PASSWORD: "postgres",
+                //UV_THREADPOOL_SIZE: "64"
+            })
+            .withCommand(['-c', 'max_connections=20'])
+            .start();
+
+        await Sleep(1000);
+
+        const postgresHttpPort = this.#postgresContainer.getMappedPort(5432);
+        const postgresHost = this.#postgresContainer.getHost();
+
+        process.env.DB_HOST = `${postgresHost}:${postgresHttpPort}`;
+        process.env.POOL_SIZE = '10';
+
+        $ResetOptions();
+
+        this.logger.info(chalk.green(`httpPort: [${postgresHttpPort}]`));
+        this.logger.info(chalk.green(`host: [${postgresHost}]`));
+        this.logger.info(chalk.yellow(`connectionString: [${goptions.connectionString}]`));
+        this.logger.info(chalk.yellow(`defaultDatabaseConnectionString: [${goptions.defaultDatabaseConnectionString }]`));
+
+        const dbOptions = {
+            start: 0,
+            iterations: 10000,
+            minextradata: 0,
+            maxextradata: 1000,
+            workerScriptFolder: './dist', //@@
+            useMultiBar: false
+        }
+
+        const dbUtils = new DatabaseUtils({
+            logger: this.logger
+        });
+        await dbUtils.CreateDatabase(dbOptions);
+
+        await Sleep(1000);
+
+        this.logger.info(chalk.green(`Starting accessLayer`));
+
+        this.#accessLayer = new DBAccessLayerManager().CreateAccessLayer({
+            accessLayerType: accessLayerType.postgresql,
+            accessLayerOptions: {
+                logger: defaultLogger,
+                usedefaultdb: false
+            } as IPGAccessLayerOptions
+        })
+
+        this.logger.info(chalk.green(`accessLayer:startdatabase()`));
+        await this.#accessLayer.StartDatabase();
+    }
+
+    StopDatabase = async () => {
+        await this.#accessLayer?.EndDatabase();
+        await JestSleep();
+        await this.#postgresContainer.stop();
+    }
+
+    StartRedis = async () => {
+        this.#ioRedisContainer = await new GenericContainer("redis")
+            .withExposedPorts(6379)
+            .start();
+        this.#ioRedisMessageProcessorUrl = `redis://${this.#ioRedisContainer.getHost()}:${this.#ioRedisContainer.getMappedPort(6379)}`;            
+    }
+
+    get ioRedisMessageProcessorUrl() {
+        return this.#ioRedisMessageProcessorUrl;
+    }
+
+    StopRedis = async () => {
+        await this.#ioRedisContainer.stop();
+    }
+}

package/src/index.ts

@@ -26,3 +26,5 @@ export * from './ipcMessageProcessorPrimary'
 export * from './ipcMessageProcessorWorker'
 export * from './ipcMessageManager'
 export * from './redisMessageHandler'
+export * from './fhir/STSFhirTypes'
+export * from './fhir/dalFhirManagerPGResEntity'

package/src/redisMessageHandler.ts

@@ -341,6 +341,29 @@ export class RedisMessageHandler extends TinyEmitter {
         return this;
     }
 
+    emitWithError(event: string, args: JSONObject, responseCb: (response: JSONObject | undefined) => void, errorCb: (error: any) => void): this {
+        (async () => {
+            try {
+                const retVal = await this.#ipcMessageManager?.SendMessage({
+                    __eventName: event,
+                    args: [ args ]
+                } as IEventPayload);            
+                // Invoke the response callback
+                responseCb(retVal);
+            } catch (error) {
+                if (this.#options.ignoreEvents) {
+                    //console.log(chalk.red(`RedisMessageHandler:emit(): ignoreEvents: [${this.#options.ignoreEvents}]`))
+                    if (this.#options.ignoreEvents.indexOf((error as any).__eventName) !== -1) {
+                        return;
+                    }
+                }
+                //this.#options.logger.error(chalk.red(`RedisMessageHandler:emit(): Error: [${JSON.stringify(error)}]`));
+                errorCb(error);
+            }
+        })();
+        return this;
+    }
+
     emitex = async(event: string, ...args: any[]): Promise<JSONObject> => {
         return (this.#ipcMessageManager as IPCMessageManager).SendMessage({
             __eventName: event,

package/src/testing/app.ts

@@ -526,8 +526,18 @@ if (cluster.isPrimary) {
         worker.redisMessageHandler.emit('GetSystemInformation', {
             group: 'primary'
         }, (response: any) => {
+            console.log(`------------------------------------------------------------------------`);
             console.log(response);
         });
 
+        worker.redisMessageHandler.emitWithError('GetSystemInformation', {
+            group: 'primary'
+        }, (response: any) => {
+            console.log(`************************************************************************`);
+            console.log(response);
+        }, (error: any) => {
+            console.log(chalk.red(`GetSystemInformation Error: [${error}]`));
+        });
+
     }, 2000);
 }