@nsshunt/stsappframework 3.1.144 → 3.1.146

package/src/fhir/dalFhirManagerIORedisJson.ts

@@ -0,0 +1,218 @@
+/* eslint @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
+import { IDomainResource, IDALFhirDataAccessManager, IFhirManagerRedisJsonOptions } from './STSFhirTypes'
+
+import { Redis, RedisOptions } from "ioredis";
+
+import chalk from 'chalk'
+import { JSONObject } from '@nsshunt/stsutils';
+
+export class DALFhirManagerIORedisJson<T> implements IDALFhirDataAccessManager<T> {
+    #options: IFhirManagerRedisJsonOptions;
+    #redis: Redis | null = null;
+    #indexName: string = 'idx:stsfhirresindex';
+
+    constructor(options: IFhirManagerRedisJsonOptions) {
+        this.#options = options;
+    }
+
+    get options() {
+        return this.#options;
+    }
+
+    set options(options: IFhirManagerRedisJsonOptions) {
+        this.#options = options;
+    }
+
+    async Start() {
+        const redisOptions: RedisOptions = {
+            showFriendlyErrorStack: true,
+            maxRetriesPerRequest: 20
+        }
+
+        this.#redis = new Redis(this.#options.redisUrl, redisOptions);
+        await this.#CreateIndex();
+    }
+
+    async Stop() {
+        if (this.#redis) {
+            this.#redis.quit();
+            this.#redis.disconnect();
+        }
+    }
+
+    #CreateIndex = async () => {
+        if (!this.#redis) {
+            return;
+        }
+
+        try {
+            //const retVal = await this.#redis.ft.dropIndex(this.#indexName);
+            const retVal = await this.#redis.call('FT.DROPINDEX', this.#indexName);
+
+            console.log(retVal);
+        } catch (error) {
+            console.log(chalk.red(error))
+        }
+
+        try {
+            const retVal = await this.#redis.call('FT.CREATE', this.#indexName, 'ON', 'HASH', 'PREFIX', '1', `${this.#options.resourceName}_`,
+                'SCHEMA', 'id', 'TEXT', 'SORTABLE');
+            console.log(retVal);
+        } catch (error) {
+            console.log(chalk.red(error))
+        }
+    }
+
+    #SearchBy = async (id: string): Promise<any> => {
+        if (!this.#redis) {
+            return null;
+        }
+
+        const query = `@id:${this.#options.resourceName}_${id}*`;
+
+        const retVal: any = await this.#redis.call('FT.SEARCH', this.#indexName, query,
+            'RETURN', '2', 'id', 'data', 'SORTBY', 'id', 'DESC', 'LIMIT', '0', '100');
+    
+        return retVal;
+    }
+
+    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.#redis) {
+            const retValRaw = await this.#redis.hgetall(this.GetResourceType(fhir))
+            if (retValRaw) {
+                try {
+                    const { id, data } = retValRaw;
+                    return JSON.parse(data) 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> {
+        if (this.#redis) {
+            const record = {
+                id: this.GetResourceType(fhir),
+                data: JSON.stringify(fhir)
+            } as any;
+
+            const retVal = await this.#redis.hmset(this.GetResourceType(fhir), record);
+
+            if (retVal) {
+                return fhir;
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+    async UpdateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+        if (this.#redis) {
+            const record = {
+                id: this.GetResourceType(fhir),
+                data: JSON.stringify(fhir)
+            } as any;
+
+            const retVal = await this.#redis.hmset(this.GetResourceType(fhir), record);
+
+            if (retVal) {
+                return fhir;
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    // eslint-disable-next-line  @typescript-eslint/no-unused-vars
+    async DeleteFhirResource(fhir: Partial<T>, ecb?: (error: Error) => void): Promise<T | null> {
+        if (this.#redis) {
+            const deleteResource = await this.GetFhirResource(fhir);
+            if (deleteResource) {
+                const retVal = await this.#redis.del(this.GetResourceType(fhir));
+                if (retVal) {
+                    return deleteResource;
+                } else {
+                    return null;
+                }
+            } else {
+                return null;
+            }
+        } else {
+            return null;
+        }
+    }
+
+    async GetFhirResources(filters: string[], ecb?: (error: Error) => void): Promise<T[] | null> {
+        const promArray: Promise<T[]>[] = [ ];
+        filters.forEach(filter => {
+            const prom = async (): Promise<T[]> => {
+                const retValArray: T[] = [ ];
+                const retVal = await this.#SearchBy(filter);
+                // First index is the total number of records in the search (does not consider limit)
+                //const listLength = retVal[0];
+
+                let index = 1;
+                const obj: JSONObject = { };
+                for (;;) {
+                    if (index >= retVal.length) {
+                        break;
+                    }
+                    const id = retVal[index++];
+                    obj[id] = { }
+                    const values = retVal[index++];
+                    let dataIndex = 0;
+                    for (let j=0; j < values.length / 2; j++) {
+                        const field = values[dataIndex++];
+                        if ((field as string).localeCompare('data') === 0) {
+                            const value = JSON.parse(values[dataIndex++]);
+                            obj[id] = value;
+                        } else {
+                            dataIndex++;
+                        }
+                    }
+                    retValArray.push(obj[id]);
+                }
+                return retValArray;
+            }
+            promArray.push(prom());
+        });
+
+        const promRetVal = await Promise.all(promArray);
+        let retVal: T[] = [ ];
+        promRetVal.forEach(prv => {
+            retVal = retVal.concat(prv);
+        });
+        return retVal;
+    }
+
+    async CreateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
+        return null;
+    }
+
+    async UpdateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
+        return null
+    }
+
+    async DeleteFhirResources(fhir: Partial<T>[], ecb?: (error: Error) => void): Promise<T[] | null> {
+        return null;
+    }
+}

package/src/fhir/dalFhirManagerPGRes.test.ts

@@ -9,6 +9,7 @@ import { JestSleep } from '@nsshunt/stsutils'
 import { TestHelpers } from './dalFhirTestHelpers'
 
 import { DALFhirManager } from './dalFhirManager'
+import chalk from 'chalk'
 
 describe("Test hl7 fhir resource data access layer - PGRes", () =>
 {
@@ -37,6 +38,17 @@ describe("Test hl7 fhir resource data access layer - PGRes", () =>
         await testHelpers.TestFhirPerson(fhirManager.fhirDataAccessManager);
     }, 30000);
 
+    test('Testing Person', async () => {
+        const iterations = 10;
+        expect.assertions(iterations + 1);
+        await testHelpers.AddFhirPersons(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['']);
+        expect(fhirResources?.length).toEqual(iterations);
+
+        console.log(chalk.yellow(JSON.stringify(fhirResources)));
+    }, 30000);
+
     afterAll(async () =>
     {
         fhirManager.fhirDataAccessManager.Stop();

package/src/fhir/dalFhirManagerPGRes.ts

@@ -1,5 +1,5 @@
 /* eslint @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import { IDBAccessLayer, IDBResource } from '@nsshunt/stsdatamanagement'
+import { IDBAccessLayer, IDBResource, IDBReturnData } from '@nsshunt/stsdatamanagement'
 
 import { IDomainResource, IDALFhirDataAccessManager, IFhirManagerPGResOptions } from './STSFhirTypes'
 
@@ -20,11 +20,11 @@ export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
         this.#options = options;
     }
 
-    Start() {
+    async Start() {
 
     }
 
-    Stop() {
+    async Stop() {
 
     }
 
@@ -115,11 +115,42 @@ export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
         }
     }
 
-    async CreateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
-        return null;
+    async GetFhirResources(filters: string[], ecb?: (error: Error) => void): Promise<T[] | null> {
+        if (!this.#accessLayer) {
+            return null;
+        }
+
+        const promArray: Promise<T[]>[] = [ ];
+        filters.forEach(filter => {
+            const prom = async (): Promise<T[]> => {
+                const retVal: T[] = [ ];
+
+                const resources = await this.#accessLayer.GetResources<T>({
+                    filters: {
+                        filter: `${this.#options.resourceName}_${filter}%`,
+                        limit: '20',
+                    }
+                })
+        
+                const dbResources = (resources.detail as IDBResource<T>[]);
+
+                dbResources.forEach(dbResource => {
+                    retVal.push(dbResource.resdesc);
+                });
+
+                return retVal;
+            }
+            promArray.push(prom());
+        })
+        const promRetVal = await Promise.all(promArray);
+        let retVal: T[] = [ ];
+        promRetVal.forEach(prv => {
+            retVal = retVal.concat(prv);
+        });
+        return retVal;
     }
 
-    async GetFhirResources(fhir: Partial<T>[], ecb?: (error: Error) => void): Promise<T[] | null> {
+    async CreateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
         return null;
     }
 

package/src/fhir/dalFhirManagerPGResEntity.test.ts

@@ -10,6 +10,7 @@ import { TestHelpers } from './dalFhirTestHelpers'
 import { JestSleep } from '@nsshunt/stsutils'
 
 import { DALFhirManager } from './dalFhirManager'
+import chalk from 'chalk'
 
 describe("Test hl7 fhir resource data access layer - PGResEntity", () =>
 {
@@ -39,6 +40,17 @@ describe("Test hl7 fhir resource data access layer - PGResEntity", () =>
         await testHelpers.TestFhirPerson(fhirManager.fhirDataAccessManager);
     }, 30000);
 
+    test('Testing Person', async () => {
+        const iterations = 10;
+        expect.assertions(iterations + 1);
+        await testHelpers.AddFhirPersons(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['']);
+        expect(fhirResources?.length).toEqual(iterations);
+
+        console.log(chalk.cyan(JSON.stringify(fhirResources)));
+    }, 30000);
+
     afterAll(async () =>
     {
         fhirManager.fhirDataAccessManager.Stop();

package/src/fhir/dalFhirManagerPGResEntity.ts

@@ -21,11 +21,11 @@ export class DALFhirManagerPGResEntity<T> implements IDALFhirDataAccessManager<T
         this.#options = options;
     }
 
-    Start() {
+    async Start() {
 
     }
 
-    Stop() {
+    async Stop() {
 
     }
 
@@ -146,11 +146,43 @@ export class DALFhirManagerPGResEntity<T> implements IDALFhirDataAccessManager<T
         }
     }
 
-    async CreateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
-        return null;
+    async GetFhirResources(filters: string[], ecb?: (error: Error) => void): Promise<T[] | null> {
+        if (!this.#accessLayer) {
+            return null;
+        }
+
+        const fhirResource = await this.#GetSTSFhirBaseResource();
+        const promArray: Promise<T[]>[] = [ ];
+        filters.forEach(filter => {
+            const prom = async (): Promise<T[]> => {
+                const retVal: T[] = [ ];
+
+                const entities = await this.#accessLayer.GetEntities<T>({
+                    filters: {
+                        resname: fhirResource.resname,
+                        filter: `${filter}%`
+                    }
+                })
+        
+                const dbResources = (entities.detail as IDBEntity<T>[]);
+
+                dbResources.forEach(dbResource => {
+                    retVal.push(dbResource.entvalue);
+                });
+
+                return retVal;
+            }
+            promArray.push(prom());
+        })
+        const promRetVal = await Promise.all(promArray);
+        let retVal: T[] = [ ];
+        promRetVal.forEach(prv => {
+            retVal = retVal.concat(prv);
+        });
+        return retVal;
     }
 
-    async GetFhirResources(fhir: Partial<T>[], ecb?: (error: Error) => void): Promise<T[] | null> {
+    async CreateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
         return null;
     }
 
@@ -161,4 +193,22 @@ export class DALFhirManagerPGResEntity<T> implements IDALFhirDataAccessManager<T
     async DeleteFhirResources(fhir: Partial<T>[], ecb?: (error: Error) => void): Promise<T[] | null> {
         return null;
     }
+
+    /*
+
+        const resources = await accessLayer.GetResources<IUserResourceType>({
+            filters: {
+                filter: 'RESCP-%',
+                limit: '10',
+            }
+        })
+
+    const entities = await accessLayer.GetEntities<IUserEntity>({
+        filters: {
+            resname: 'user-t2',
+            filter: '%'
+        }
+    })
+        */
+
 }

package/src/fhir/dalFhirManagerRedisJson.test.ts

@@ -8,6 +8,7 @@ import { TestHelpers } from './dalFhirTestHelpers'
 import { JestSleep } from '@nsshunt/stsutils'
 
 import { DALFhirManager } from './dalFhirManager'
+import chalk from 'chalk'
 
 describe.skip("Test hl7 fhir resource data access layer - RedisJson", () =>
 {
@@ -28,7 +29,7 @@ describe.skip("Test hl7 fhir resource data access layer - RedisJson", () =>
             }
         });
 
-        fhirManager.fhirDataAccessManager.Start();
+        await fhirManager.fhirDataAccessManager.Start();
     }, 30000);
 
     test('Testing Person', async () => {
@@ -36,9 +37,20 @@ describe.skip("Test hl7 fhir resource data access layer - RedisJson", () =>
         await testHelpers.TestFhirPerson(fhirManager.fhirDataAccessManager);
     }, 30000);
 
+    test('Testing Person', async () => {
+        const iterations = 10;
+        expect.assertions(iterations + 1);
+        await testHelpers.AddFhirPersons(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['']);
+        expect(fhirResources?.length).toEqual(iterations);
+
+        console.log(chalk.green(JSON.stringify(fhirResources)));
+    }, 30000);
+
     afterAll(async () =>
     {
-        fhirManager.fhirDataAccessManager.Stop();
+        await fhirManager.fhirDataAccessManager.Stop();
         await JestSleep();
         await testHelpers.StopRedis();
     }, 5000);

package/src/fhir/dalFhirManagerRedisJson.ts

@@ -1,11 +1,15 @@
 /* eslint @typescript-eslint/no-unused-vars: 0 */  // --> OFF
+/* eslint @typescript-eslint/no-explicit-any: 0 */  // --> OFF
 import { IDomainResource, IDALFhirDataAccessManager, IFhirManagerRedisJsonOptions } from './STSFhirTypes'
 
-import { Redis, RedisOptions } from "ioredis";
+import { SchemaFieldTypes, createClient, RedisClientType, AggregateSteps, AggregateGroupByReducers } from 'redis';
+
+import chalk from 'chalk'
 
 export class DALFhirManagerRedisJson<T> implements IDALFhirDataAccessManager<T> {
     #options: IFhirManagerRedisJsonOptions;
-    #redisSubscriber: Redis | null = null;
+    #redis: RedisClientType | null = null;
+    #indexName: string = 'idx:stsfhirresindex';
 
     constructor(options: IFhirManagerRedisJsonOptions) {
         this.#options = options;
@@ -19,19 +23,71 @@ export class DALFhirManagerRedisJson<T> implements IDALFhirDataAccessManager<T>
         this.#options = options;
     }
 
-    Start() {
-        const redisOptions: RedisOptions = {
-            showFriendlyErrorStack: true,
-            maxRetriesPerRequest: 20
+    #CreateIndex = async () => {
+        if (!this.#redis) {
+            return;
+        }
+
+        try {
+            const retVal = await this.#redis.ft.dropIndex(this.#indexName);
+            console.log(retVal);
+        } catch (error) {
+            console.log(chalk.red(error))
         }
+    
+        try {
+            const retVal = await this.#redis.ft.create(this.#indexName, { // serviceIndexInstant
+                'id': { type: SchemaFieldTypes.TEXT, SORTABLE: true }
+            }, {
+                ON: 'HASH',
+                PREFIX: `${this.#options.resourceName}_`
+            });
+            console.log(retVal);
+        } catch (error) {
+            console.log(chalk.red(error))
+        }
+    }
+
+    #SearchBy = async (id: string) => {
+        if (!this.#redis) {
+            return null;
+        }
+
+        const queryOptions = {
+            RETURN: [ 'id', 'data' ],
+            LIMIT: {
+                from: 0,
+                size: 100
+            },
+            SORTBY: {
+                BY: 'id',
+                DIRECTION: 'DESC'
+            }
+        } as any;
+
+        const query = `@id:${this.#options.resourceName}_${id}*`;
+
+        const retVal = await this.#redis.ft.search(this.#indexName, query, queryOptions);
 
-        this.#redisSubscriber = new Redis(this.#options.redisUrl, redisOptions);
+        return retVal;
     }
 
-    Stop() {
-        if (this.#redisSubscriber) {
-            this.#redisSubscriber.quit();
-            this.#redisSubscriber.disconnect();
+    async Start() {
+        this.#redis = await createClient({url: this.#options.redisUrl})
+            .on('error', error => console.error(chalk.red(`Error connecting to redis. Error: [${error}]`)))
+            .connect() as any
+
+        if (this.#redis) {
+            await this.#CreateIndex();
+        } else {
+            console.error(chalk.red(`this.#redis instance not created.`))
+        }
+    }
+
+    async Stop() {
+        if (this.#redis) {
+            //await this.#redis.quit();
+            await this.#redis.disconnect();
         }
     }
 
@@ -40,11 +96,12 @@ export class DALFhirManagerRedisJson<T> implements IDALFhirDataAccessManager<T>
     }
 
     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 (this.#redis) {
+            const retValRaw = await this.#redis.HGETALL(this.GetResourceType(fhir))
             if (retValRaw) {
                 try {
-                    return JSON.parse(retValRaw) as T;
+                    const { id, data } = retValRaw;
+                    return JSON.parse(data) as T;
                 } catch (error: unknown) {
                     if (ecb) {
                         ecb(error as Error);
@@ -61,19 +118,43 @@ export class DALFhirManagerRedisJson<T> implements IDALFhirDataAccessManager<T>
 
     // 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;
+        if (this.#redis) {
+            const record = {
+                id: this.GetResourceType(fhir),
+                data: JSON.stringify(fhir)
+            } as any;
+
+            const keyValuePairs: any = Object.entries(record).flat();
+
+            const retVal = await this.#redis.HSET(this.GetResourceType(fhir), keyValuePairs);
+
+            if (retVal) {
+                return fhir;
+            } else {
+                return null;
+            }
         } else {
+            console.error(chalk.red(`this.#redis not defined.`))
             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;
+        if (this.#redis) {
+            const record = {
+                id: this.GetResourceType(fhir),
+                data: JSON.stringify(fhir)
+            } as any;
+
+            const keyValuePairs: any = Object.entries(record).flat();
+
+            const retVal = await this.#redis.HSET(this.GetResourceType(fhir), keyValuePairs);
+            if (retVal >= 0) {
+                return fhir;
+            } else {
+                return null;
+            }
         } else {
             return null;
         }
@@ -81,11 +162,15 @@ export class DALFhirManagerRedisJson<T> implements IDALFhirDataAccessManager<T>
 
     // 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;
+        if (this.#redis) {
+            const deleteResource = await this.GetFhirResource(fhir);
+            if (deleteResource) {
+                const retVal = await this.#redis.del(this.GetResourceType(fhir));
+                if (retVal > 0) {
+                    return deleteResource;
+                } else {
+                    return null;
+                }
             } else {
                 return null;
             }
@@ -94,11 +179,29 @@ export class DALFhirManagerRedisJson<T> implements IDALFhirDataAccessManager<T>
         }
     }
 
-    async CreateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
-        return null;
+    async GetFhirResources(filters: string[], ecb?: (error: Error) => void): Promise<T[] | null> {
+        const promArray: Promise<T[]>[] = [ ];
+        filters.forEach(filter => {
+            const prom = async (): Promise<T[]> => {
+                const retValArray: T[] = [ ];
+                const retVal = await this.#SearchBy(filter);
+                retVal?.documents.forEach(doc => {
+                    retValArray.push(JSON.parse(doc.value.data as string) as T);
+                })
+                return retValArray;
+            }
+            promArray.push(prom());
+        });
+
+        const promRetVal = await Promise.all(promArray);
+        let retVal: T[] = [ ];
+        promRetVal.forEach(prv => {
+            retVal = retVal.concat(prv);
+        });
+        return retVal;
     }
 
-    async GetFhirResources(fhir: Partial<T>[], ecb?: (error: Error) => void): Promise<T[] | null> {
+    async CreateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
         return null;
     }