@nsshunt/stsappframework 3.1.146 → 3.1.148

package/src/fhir/dalFhirManagerIORedisJson.ts

@@ -6,22 +6,14 @@ import { Redis, RedisOptions } from "ioredis";
 
 import chalk from 'chalk'
 import { JSONObject } from '@nsshunt/stsutils';
+import { DALFhirManagerBase } from './dalFhirManagerBase';
 
-export class DALFhirManagerIORedisJson<T> implements IDALFhirDataAccessManager<T> {
-    #options: IFhirManagerRedisJsonOptions;
+export class DALFhirManagerIORedisJson<T> extends DALFhirManagerBase<T> implements IDALFhirDataAccessManager<T> {
     #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;
+        super(options);
     }
 
     async Start() {
@@ -30,7 +22,7 @@ export class DALFhirManagerIORedisJson<T> implements IDALFhirDataAccessManager<T
             maxRetriesPerRequest: 20
         }
 
-        this.#redis = new Redis(this.#options.redisUrl, redisOptions);
+        this.#redis = new Redis((this.options as IFhirManagerRedisJsonOptions).redisUrl, redisOptions);
         await this.#CreateIndex();
     }
 
@@ -56,7 +48,7 @@ export class DALFhirManagerIORedisJson<T> implements IDALFhirDataAccessManager<T
         }
 
         try {
-            const retVal = await this.#redis.call('FT.CREATE', this.#indexName, 'ON', 'HASH', 'PREFIX', '1', `${this.#options.resourceName}_`,
+            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) {
@@ -69,7 +61,7 @@ export class DALFhirManagerIORedisJson<T> implements IDALFhirDataAccessManager<T
             return null;
         }
 
-        const query = `@id:${this.#options.resourceName}_${id}*`;
+        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');
@@ -78,141 +70,191 @@ export class DALFhirManagerIORedisJson<T> implements IDALFhirDataAccessManager<T
     }
 
     GetResourceType(fhir: Partial<T>): string {
-        return `${this.#options.resourceName}_${(fhir as Partial<IDomainResource>).id}`;
+        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);
+    async GetFhirResource(fhir: Partial<T>, ecb?: (fhir: Partial<T>, error: Error) => void): Promise<T | null> {
+        try {
+            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(fhir, error as Error);
+                        }
+                        return null;
                     }
+                } else {
                     return null;
                 }
             } else {
                 return null;
             }
-        } else {
+        } catch (error) {
+            if (ecb) {
+                ecb(fhir, error as Error);
+            }
             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;
+    async CreateFhirResource(fhir: T, ecb?: (fhir: T, error: Error) => void): Promise<T | null> {
+        try {
+            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);
+                const retVal = await this.#redis.hmset(this.GetResourceType(fhir), record);
 
-            if (retVal) {
-                return fhir;
+                if (retVal) {
+                    return fhir;
+                } else {
+                    return null;
+                }
             } else {
                 return null;
             }
-        } else {
+        } catch (error) {
+            if (ecb) {
+                ecb(fhir, error as Error);
+            }
             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;
+    async UpdateFhirResource(fhir: T, ecb?: (fhir: T, error: Error) => void): Promise<T | null> {
+        try {
+            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);
+                const retVal = await this.#redis.hmset(this.GetResourceType(fhir), record);
 
-            if (retVal) {
-                return fhir;
+                if (retVal) {
+                    return fhir;
+                } else {
+                    return null;
+                }
             } else {
                 return null;
             }
-        } else {
+        } catch (error) {
+            if (ecb) {
+                ecb(fhir, error as Error);
+            }
             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;
+    async DeleteFhirResource(fhir: Partial<T>, ecb?: (fhir: Partial<T>, error: Error) => void): Promise<T | null> {
+        try {
+            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;
             }
-        } else {
+        } catch (error) {
+            if (ecb) {
+                ecb(fhir, error as Error);
+            }
             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++;
+    async GetFhirResources(filters: string[], ecb?: (filters: string[], error: Error) => void): Promise<T[] | null> {
+        try {
+            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]);
                     }
-                    retValArray.push(obj[id]);
+                    return retValArray;
                 }
-                return retValArray;
-            }
-            promArray.push(prom());
-        });
+                promArray.push(prom());
+            });
 
-        const promRetVal = await Promise.all(promArray);
-        let retVal: T[] = [ ];
-        promRetVal.forEach(prv => {
-            retVal = retVal.concat(prv);
-        });
-        return retVal;
+            const promRetVal = await Promise.all(promArray);
+            let retVal: T[] = [ ];
+            promRetVal.forEach(prv => {
+                retVal = retVal.concat(prv);
+            });
+            return retVal;
+        } catch (error) {
+            if (ecb) {
+                ecb(filters, error as Error);
+            }
+            return null;
+        }
     }
 
-    async CreateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
-        return null;
+    async CreateFhirResources(fhir: T[], ecb?: (fhir: T, error: Error) => void): Promise<(T | null)[]> {
+        const promArray: Promise<T | null>[] = [ ];
+        fhir.forEach(async (f) => {
+            promArray.push(this.CreateFhirResource(f, ecb));
+        })
+        const promRetVal = await Promise.all(promArray);
+        return promRetVal;
     }
 
-    async UpdateFhirResources(fhir: T[], ecb?: (error: Error) => void): Promise<T[] | null> {
-        return null
+    async UpdateFhirResources(fhir: T[], ecb?: (fhir: T, error: Error) => void): Promise<(T | null)[]> {
+        const promArray: Promise<T | null>[] = [ ];
+        fhir.forEach(async (f) => {
+            promArray.push(this.UpdateFhirResource(f, ecb));
+        })
+        const promRetVal = await Promise.all(promArray);
+        return promRetVal;
     }
 
-    async DeleteFhirResources(fhir: Partial<T>[], ecb?: (error: Error) => void): Promise<T[] | null> {
-        return null;
+    async DeleteFhirResources(fhir: Partial<T>[], ecb?: (fhir: Partial<T>, error: Error) => void): Promise<(T | null)[]> {
+        const promArray: Promise<T | null>[] = [ ];
+        fhir.forEach(async (f) => {
+            promArray.push(this.DeleteFhirResource(f, ecb));
+        })
+        const promRetVal = await Promise.all(promArray);
+        return promRetVal;
     }
 }

package/src/fhir/dalFhirManagerPGRes.test.ts

@@ -38,7 +38,7 @@ describe("Test hl7 fhir resource data access layer - PGRes", () =>
         await testHelpers.TestFhirPerson(fhirManager.fhirDataAccessManager);
     }, 30000);
 
-    test('Testing Person', async () => {
+    test('Testing Persons with Search', async () => {
         const iterations = 10;
         expect.assertions(iterations + 1);
         await testHelpers.AddFhirPersons(fhirManager.fhirDataAccessManager, iterations);
@@ -49,6 +49,39 @@ describe("Test hl7 fhir resource data access layer - PGRes", () =>
         console.log(chalk.yellow(JSON.stringify(fhirResources)));
     }, 30000);
 
+    test('Testing Persons with Bulk Insert', async () => {
+        const iterations = 10;
+        expect.assertions(2);
+        await testHelpers.AddFhirPersonsByArray(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['bulk_']);
+        expect(fhirResources?.length).toEqual(iterations);
+
+        console.log(chalk.rgb(133, 161, 142)(JSON.stringify(fhirResources)));
+    }, 30000);
+
+    test('Testing Persons with Bulk Update', async () => {
+        const iterations = 10;
+        expect.assertions(2);
+        await testHelpers.UpdateFhirPersonsByArray(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['bulk_']);
+        expect(fhirResources?.length).toEqual(iterations);
+
+        console.log(chalk.rgb(157, 133, 161)(JSON.stringify(fhirResources)));
+    }, 30000);
+
+    test('Testing Persons with Bulk Delete', async () => {
+        const iterations = 7;
+        expect.assertions(2);
+        await testHelpers.DeleteFhirPersonsByArray(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['bulk_']);
+        expect(fhirResources?.length).toEqual(10 - iterations);
+
+        console.log(chalk.rgb(105, 97, 50)(JSON.stringify(fhirResources)));
+    }, 30000);
+
     afterAll(async () =>
     {
         fhirManager.fhirDataAccessManager.Stop();

package/src/fhir/dalFhirManagerPGRes.ts

@@ -1,23 +1,15 @@
 /* eslint @typescript-eslint/no-unused-vars: 0 */  // --> OFF
-import { IDBAccessLayer, IDBResource, IDBReturnData } from '@nsshunt/stsdatamanagement'
+import { IDBAccessLayer, IDBResource } from '@nsshunt/stsdatamanagement'
 
-import { IDomainResource, IDALFhirDataAccessManager, IFhirManagerPGResOptions } from './STSFhirTypes'
+import { IDALFhirDataAccessManager, IFhirManagerPGResOptions } from './STSFhirTypes'
+import { DALFhirManagerBase } from './dalFhirManagerBase';
 
-export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
-    #options: IFhirManagerPGResOptions;
+export class DALFhirManagerPGRes<T> extends DALFhirManagerBase<T> implements IDALFhirDataAccessManager<T> {
     #accessLayer: IDBAccessLayer;
 
     constructor(options: IFhirManagerPGResOptions) {
-        this.#options = options;
-        this.#accessLayer = this.#options.accessLayer;
-    }
-
-    get options() {
-        return this.#options;
-    }
-
-    set options(options: IFhirManagerPGResOptions) {
-        this.#options = options;
+        super(options);
+        this.#accessLayer = (this.options as IFhirManagerPGResOptions).accessLayer;
     }
 
     async Start() {
@@ -28,11 +20,7 @@ export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
 
     }
 
-    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> {
+    async GetFhirResource(fhir: Partial<T>, ecb?: (fhir: Partial<T>, error: Error) => void): Promise<T | null> {
         if (!this.#accessLayer) {
             return null;
         }
@@ -44,7 +32,7 @@ export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
         });
         if (retVal.error) {
             if (ecb) {
-                ecb(retVal.error.error);
+                ecb(fhir, retVal.error.error);
             }
             return null;
         } else {
@@ -52,20 +40,20 @@ export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
         }
     }
 
-    async CreateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+    async CreateFhirResource(fhir: T, ecb?: (fhir: T, error: Error) => void): Promise<T | null> {
         if (!this.#accessLayer) {
             return null;
         }
 
         const retVal = await this.#accessLayer.CreateResource<T>({
             filters: {
-                dbactionuser: this.#options.dbactionuser,
+                dbactionuser: this.options.dbactionuser,
                 resname: this.GetResourceType(fhir)
             }
         }, fhir);
         if (retVal.error) {
             if (ecb) {
-                ecb(retVal.error.error);
+                ecb(fhir, retVal.error.error);
             }
             return null;
         } else {
@@ -73,20 +61,20 @@ export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
         }
     }
 
-    async UpdateFhirResource(fhir: T, ecb?: (error: Error) => void): Promise<T | null> {
+    async UpdateFhirResource(fhir: T, ecb?: (fhir: T, error: Error) => void): Promise<T | null> {
         if (!this.#accessLayer) {
             return null;
         }
 
         const retVal = await this.#accessLayer.UpdateResource<T>({
             filters: {
-                dbactionuser: this.#options.dbactionuser,
+                dbactionuser: this.options.dbactionuser,
                 resname: this.GetResourceType(fhir)
             }
         }, fhir);
         if (retVal.error) {
             if (ecb) {
-                ecb(retVal.error.error);
+                ecb(fhir, retVal.error.error);
             }
             return null;
         } else {
@@ -94,20 +82,20 @@ export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
         }
     }
 
-    async DeleteFhirResource(fhir: Partial<T>, ecb?: (error: Error) => void): Promise<T | null> {
+    async DeleteFhirResource(fhir: Partial<T>, ecb?: (fhir: Partial<T>, error: Error) => void): Promise<T | null> {
         if (!this.#accessLayer) {
             return null;
         }
 
         const retVal = await this.#accessLayer.DeleteResource<T>({
             filters: {
-                dbactionuser: this.#options.dbactionuser,
+                dbactionuser: this.options.dbactionuser,
                 resname: this.GetResourceType(fhir)
             }
         });
         if (retVal.error) {
             if (ecb) {
-                ecb(retVal.error.error);
+                ecb(fhir, retVal.error.error);
             }
             return null;
         } else {
@@ -115,50 +103,45 @@ export class DALFhirManagerPGRes<T> implements IDALFhirDataAccessManager<T> {
         }
     }
 
-    async GetFhirResources(filters: string[], ecb?: (error: Error) => void): Promise<T[] | null> {
+    async GetFhirResources(filters: string[], ecb?: (filters: string[], 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;
+        try {
+            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;
+        } catch (error) {
+            if (ecb) {
+                ecb(filters, error as Error);
             }
-            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;
+            return null;
+        }
     }
 }

package/src/fhir/dalFhirManagerPGResEntity.test.ts

@@ -40,7 +40,7 @@ describe("Test hl7 fhir resource data access layer - PGResEntity", () =>
         await testHelpers.TestFhirPerson(fhirManager.fhirDataAccessManager);
     }, 30000);
 
-    test('Testing Person', async () => {
+    test('Testing Persons with Search', async () => {
         const iterations = 10;
         expect.assertions(iterations + 1);
         await testHelpers.AddFhirPersons(fhirManager.fhirDataAccessManager, iterations);
@@ -51,6 +51,39 @@ describe("Test hl7 fhir resource data access layer - PGResEntity", () =>
         console.log(chalk.cyan(JSON.stringify(fhirResources)));
     }, 30000);
 
+    test('Testing Persons with Bulk Insert', async () => {
+        const iterations = 10;
+        expect.assertions(2);
+        await testHelpers.AddFhirPersonsByArray(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['bulk_']);
+        expect(fhirResources?.length).toEqual(iterations);
+
+        console.log(chalk.rgb(133, 161, 142)(JSON.stringify(fhirResources)));
+    }, 30000);
+
+    test('Testing Persons with Bulk Update', async () => {
+        const iterations = 10;
+        expect.assertions(2);
+        await testHelpers.UpdateFhirPersonsByArray(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['bulk_']);
+        expect(fhirResources?.length).toEqual(iterations);
+
+        console.log(chalk.rgb(157, 133, 161)(JSON.stringify(fhirResources)));
+    }, 30000);
+
+    test('Testing Persons with Bulk Delete', async () => {
+        const iterations = 7;
+        expect.assertions(2);
+        await testHelpers.DeleteFhirPersonsByArray(fhirManager.fhirDataAccessManager, iterations);
+
+        const fhirResources = await fhirManager.fhirDataAccessManager.GetFhirResources(['bulk_']);
+        expect(fhirResources?.length).toEqual(10 - iterations);
+
+        console.log(chalk.rgb(105, 97, 50)(JSON.stringify(fhirResources)));
+    }, 30000);
+
     afterAll(async () =>
     {
         fhirManager.fhirDataAccessManager.Stop();