oro-sdk 2.1.4-dev1.0 → 2.2.1

package/src/helpers/client.ts

@@ -2,7 +2,7 @@ import {
     PopulatedWorkflowData,
     MetadataCategory,
     SelectedAnswersData,
-} from '../models'
+} from 'oro-sdk-apis'
 import { PersonalInformations } from '../models/client'
 
 const personalMetaToPrefix = {

package/src/helpers/patient-registration.ts

@@ -1,28 +1,28 @@
 import {
     Consult,
     ConsultationImageMeta,
-    getImagesFromIndexDb,
-    getWorkflowDataByCategory,
-    filterTriggeredAnsweredWithKind,
-    MedicalStatus,
-    OroClient,
-    PersonalMeta,
-    Practitioner,
-    RegisterPatientOutput,
-} from '..'
-import {
     ConsultationMeta,
     ConsultRequest,
     DocumentType,
     IndexKey,
     MedicalMeta,
+    MedicalStatus,
     MetadataCategory,
+    PersonalMeta,
+    Practitioner,
     PreferenceMeta,
     RawConsultationMeta,
     Uuid,
     VaultIndex,
     WorkflowData,
-} from '../models'
+} from 'oro-sdk-apis'
+import {
+    filterTriggeredAnsweredWithKind,
+    getImagesFromIndexDb,
+    getWorkflowDataByCategory,
+    OroClient,
+    RegisterPatientOutput,
+} from '..'
 
 const MAX_RETRIES = 15
 
@@ -50,11 +50,8 @@ export async function registerPatient(
 
             // Retrieving practitioners
             if (!practitionerAdmin)
-                practitionerAdmin = (
-                    await oroClient.practiceClient.practiceGetFromUuid(
-                        consultRequest.uuidPractice
-                    )
-                ).uuidAdmin
+                practitionerAdmin = (await oroClient.practiceClient.practiceGetFromUuid(consultRequest.uuidPractice))
+                    .uuidAdmin
 
             let practitioners: Practitioner[] = await oroClient.practiceClient
                 .practiceGetPractitioners(consultRequest.uuidPractice)
@@ -65,61 +62,35 @@ export async function registerPatient(
 
             // Creating consult
             if (!consult) {
-                consult = await getOrCreatePatientConsultationUuid(
-                    consultRequest,
-                    oroClient
-                )
+                consult = await getOrCreatePatientConsultationUuid(consultRequest, oroClient)
             }
 
             // Creating lockbox
-            if (!lockboxUuid)
-                lockboxUuid = await getOrCreatePatientLockbox(oroClient)
+            if (!lockboxUuid) lockboxUuid = await getOrCreatePatientLockbox(oroClient)
 
-            isExistingPatient = await patientConsultExists(
-                consult,
-                lockboxUuid,
-                oroClient
-            ).catch((err) => {
+            isExistingPatient = await patientConsultExists(consult, lockboxUuid, oroClient).catch((err) => {
                 console.error(`Error when retrieving existing consults ${err}`)
                 return false
             })
-            await oroClient
-                .grantLockbox(practitionerAdmin, lockboxUuid)
-                .catch((err) => {
-                    console.error(
-                        `Error while granting lockbox to practitioner admin ${practitionerAdmin}`,
-                        err
-                    )
-                    // if we cannot grant to the admin, then the registration will fail
-                    throw err
-                })
+            await oroClient.grantLockbox(practitionerAdmin, lockboxUuid).catch((err) => {
+                console.error(`Error while granting lockbox to practitioner admin ${practitionerAdmin}`, err)
+                // if we cannot grant to the admin, then the registration will fail
+                throw err
+            })
 
             // Patient Grant to practice
             let grantPromises = practitioners
-                .filter(
-                    (practitioner) => practitioner.uuid !== practitionerAdmin
-                )
+                .filter((practitioner) => practitioner.uuid !== practitionerAdmin)
                 .map(async (practitioner) => {
-                    return oroClient
-                        .grantLockbox(practitioner.uuid, lockboxUuid!)
-                        .catch((err) => {
-                            console.error(
-                                `Error while granting lockbox to practitioner`,
-                                err
-                            )
-                            // Acceptable to continue as admin has already been granted, but we should still try to retry
-                            if (retry <= 1) return
-                            else throw err
-                        })
+                    return oroClient.grantLockbox(practitioner.uuid, lockboxUuid!).catch((err) => {
+                        console.error(`Error while granting lockbox to practitioner`, err)
+                        // Acceptable to continue as admin has already been granted, but we should still try to retry
+                        if (retry <= 1) return
+                        else throw err
+                    })
                 })
 
-            await storePatientData(
-                consult.uuid,
-                consultRequest.isoLanguageRequired,
-                lockboxUuid,
-                workflow,
-                oroClient
-            )
+            await storePatientData(consult.uuid, consultRequest.isoLanguageRequired, lockboxUuid, workflow, oroClient)
 
             // the index will identify in which lockbox a consultation live
             let consultIndex: VaultIndex = {
@@ -135,19 +106,13 @@ export async function registerPatient(
             }
 
             let consultIndexPromises = practitioners.map(async (practitioner) => {
-                return oroClient
-                    .vaultIndexAdd(consultIndex, practitioner.uuid)
-                    .catch((err) => {
-                        console.error(
-                            `Error while adding to the practitioner's index ${practitioner.uuid}`,
-                            err
-                        )
-                        /// it's acceptable to continue registration
-                        return
-                    })
+                return oroClient.vaultIndexAdd(consultIndex, practitioner.uuid).catch((err) => {
+                    console.error(`Error while adding to the practitioner's index ${practitioner.uuid}`, err)
+                    /// it's acceptable to continue registration
+                    return
+                })
             })
 
-
             //DEPRECATED: REMOVE ME : BEGIN /////////////////////////////////////////
 
             let deprecatedConsultIndex: VaultIndex = {
@@ -163,30 +128,22 @@ export async function registerPatient(
             }
 
             let deprecatedConsultIndexPromises = practitioners.map(async (practitioner) => {
-                return oroClient
-                    .vaultIndexAdd(deprecatedConsultIndex, practitioner.uuid)
-                    .catch((err) => {
-                        console.error(
-                            `Error while adding to the practitioner's index ${practitioner.uuid}`,
-                            err
-                        )
-                        /// it's acceptable to continue registration
-                        return
-                    })
+                return oroClient.vaultIndexAdd(deprecatedConsultIndex, practitioner.uuid).catch((err) => {
+                    console.error(`Error while adding to the practitioner's index ${practitioner.uuid}`, err)
+                    /// it's acceptable to continue registration
+                    return
+                })
             })
 
             //DEPRECATED: REMOVE ME : END /////////////////////////////////////////
 
-
             if (masterKey && !isExistingPatient) {
                 // generate and store recovery payload
-                await oroClient
-                    .updateMasterKey(patientUuid, masterKey, lockboxUuid)
-                    .catch((err) => {
-                        console.error(`Error while updating master key`, err)
-                        /// it's acceptable to continue registration
-                        return
-                    })
+                await oroClient.updateMasterKey(patientUuid, masterKey, lockboxUuid).catch((err) => {
+                    console.error(`Error while updating master key`, err)
+                    /// it's acceptable to continue registration
+                    return
+                })
             } else {
                 // we did not set the master key so we do not return it
                 masterKey = undefined
@@ -202,10 +159,7 @@ export async function registerPatient(
                         2
                     )
                     .catch((err) => {
-                        console.error(
-                            `Error while updating security questions`,
-                            err
-                        )
+                        console.error(`Error while updating security questions`, err)
                         /// it's acceptable to continue registration
                         return
                     })
@@ -220,9 +174,7 @@ export async function registerPatient(
             // if we got through the complete flow, the registration succeeded
             break
         } catch (err) {
-            console.error(
-                `Error occured during registration, retrying... Retries remaining: ${retry}`
-            )
+            console.error(`Error occured during registration, retrying... Retries remaining: ${retry}`)
             continue
         }
     }
@@ -255,17 +207,10 @@ async function patientConsultExists(
         category: MetadataCategory.Consultation,
         documentType: DocumentType.PopulatedWorkflowData,
     }
-    let manifest = await oroClient.vaultClient.lockboxMetadataGet(
-        lockboxUuid,
-        ['consultationId'],
-        [],
-        publicMetadata
-    )
+    let manifest = await oroClient.vaultClient.lockboxMetadataGet(lockboxUuid, ['consultationId'], [], publicMetadata)
     return (
         manifest[0].findIndex(
-            (v: { consultationId: Uuid }) =>
-                v.consultationId != null &&
-                v.consultationId !== currentConsultation.uuid
+            (v: { consultationId: Uuid }) => v.consultationId != null && v.consultationId !== currentConsultation.uuid
         ) !== -1
     )
 }
@@ -276,28 +221,21 @@ async function patientConsultExists(
  * @param oroClient
  * @returns the consult Uuid
  */
-async function getOrCreatePatientConsultationUuid(
-    consult: ConsultRequest,
-    oroClient: OroClient
-): Promise<Consult> {
+async function getOrCreatePatientConsultationUuid(consult: ConsultRequest, oroClient: OroClient): Promise<Consult> {
     let payment = await oroClient.practiceClient.practiceGetPayment(
         consult.uuidPractice,
         consult.idStripeInvoiceOrPaymentIntent
     )
     if (payment && payment.uuidConsult) {
-        return oroClient.consultClient
-            .getConsultByUUID(payment.uuidConsult)
-            .catch((err) => {
-                console.error('Error while retrieving consult', err)
-                throw err
-            })
+        return oroClient.consultClient.getConsultByUUID(payment.uuidConsult).catch((err) => {
+            console.error('Error while retrieving consult', err)
+            throw err
+        })
     } else {
-        return await oroClient.consultClient
-            .consultCreate(consult)
-            .catch((err) => {
-                console.error('Error while creating consult', err)
-                throw err
-            })
+        return await oroClient.consultClient.consultCreate(consult).catch((err) => {
+            console.error('Error while creating consult', err)
+            throw err
+        })
     }
 }
 
@@ -309,9 +247,7 @@ async function getOrCreatePatientConsultationUuid(
 async function getOrCreatePatientLockbox(oroClient: OroClient): Promise<Uuid> {
     let grants = await oroClient.getGrants(undefined, true)
     if (grants.length > 0) {
-        console.log(
-            'The grant has already been created, skipping lockbox create step'
-        )
+        console.log('The grant has already been created, skipping lockbox create step')
         return grants[0].lockboxUuid!
     } else
         return (
@@ -340,12 +276,7 @@ async function storePatientData(
 ): Promise<(Uuid | void)[]> {
     // Create and store registration data
     return Promise.all([
-        storeImageAliases(
-            consultationId,
-            lockboxUuid,
-            workflow,
-            oroClient
-        ).catch((err) => {
+        storeImageAliases(consultationId, lockboxUuid, workflow, oroClient).catch((err) => {
             console.error('[SDK] Some errors happened during image upload', err)
         }),
         // Storing Raw data first
@@ -359,31 +290,29 @@ async function storePatientData(
             },
             {}
         ),
-        getWorkflowDataByCategory(workflow, MetadataCategory.Consultation).then(
-            (data) =>
-                oroClient.getOrInsertJsonData<ConsultationMeta>(
-                    lockboxUuid,
-                    data,
-                    {
-                        category: MetadataCategory.Consultation,
-                        documentType: DocumentType.PopulatedWorkflowData,
-                        consultationId, // TODO: deprecated. Will finally only be in privateMetadata
-                    },
-                    { consultationId }
-                )
+        getWorkflowDataByCategory(workflow, MetadataCategory.Consultation).then((data) =>
+            oroClient.getOrInsertJsonData<ConsultationMeta>(
+                lockboxUuid,
+                data,
+                {
+                    category: MetadataCategory.Consultation,
+                    documentType: DocumentType.PopulatedWorkflowData,
+                    consultationId, // TODO: deprecated. Will finally only be in privateMetadata
+                },
+                { consultationId }
+            )
         ),
-        getWorkflowDataByCategory(workflow, MetadataCategory.Medical).then(
-            (data) =>
-                oroClient.getOrInsertJsonData<MedicalMeta>(
-                    lockboxUuid,
-                    data,
-                    {
-                        category: MetadataCategory.Medical,
-                        documentType: DocumentType.PopulatedWorkflowData,
-                        consultationIds: [consultationId!],
-                    },
-                    {}
-                )
+        getWorkflowDataByCategory(workflow, MetadataCategory.Medical).then((data) =>
+            oroClient.getOrInsertJsonData<MedicalMeta>(
+                lockboxUuid,
+                data,
+                {
+                    category: MetadataCategory.Medical,
+                    documentType: DocumentType.PopulatedWorkflowData,
+                    consultationIds: [consultationId!],
+                },
+                {}
+            )
         ),
         extractAndStorePersonalWorkflowData(
             workflow,
@@ -424,16 +353,12 @@ async function storeImageAliases(
     workflow: WorkflowData,
     oroClient: OroClient
 ): Promise<(Uuid | void)[]> {
-    const images = await getImagesFromIndexDb(
-        (await filterTriggeredAnsweredWithKind(workflow, 'images-alias')).flat()
-    )
+    const images = await getImagesFromIndexDb((await filterTriggeredAnsweredWithKind(workflow, 'images-alias')).flat())
 
     const nonNullImages = images.filter((img) => !!img)
 
     if (images.length !== nonNullImages.length) {
-        console.error(
-            '[SDK] Some images have not been found, they have been skipped.'
-        )
+        console.error('[SDK] Some images have not been found, they have been skipped.')
     }
 
     let promises = nonNullImages.map((image) => {
@@ -465,16 +390,10 @@ export async function extractAndStorePersonalWorkflowData(
     workflow: WorkflowData,
     lockboxUuid: Uuid,
     consultationId: Uuid,
-    category:
-        | MetadataCategory.Personal
-        | MetadataCategory.ChildPersonal
-        | MetadataCategory.OtherPersonal,
+    category: MetadataCategory.Personal | MetadataCategory.ChildPersonal | MetadataCategory.OtherPersonal,
     oroClient: OroClient
 ): Promise<Uuid | void> {
-    return getWorkflowDataByCategory(
-        workflow,
-        (category as unknown) as MetadataCategory
-    ).then((data) => {
+    return getWorkflowDataByCategory(workflow, category as unknown as MetadataCategory).then((data) => {
         if (Object.keys(data.fields).length === 0) return
         return oroClient.getOrInsertJsonData<PersonalMeta>(
             lockboxUuid,

package/src/helpers/vault-grants.ts

@@ -1,5 +1,5 @@
 import { CryptoRSA, uuidParse} from "oro-toolbox"
-import { EncryptedIndexEntry, Grant, IndexConsultLockbox } from ".."
+import { EncryptedIndexEntry, Grant, IndexConsultLockbox } from "oro-sdk-apis"
 
 /**
  * Decrypts and returns the encrypted grants

package/src/helpers/workflow.ts

@@ -1,4 +1,5 @@
 import { getMany } from 'idb-keyval'
+import { WorkflowAnswersMissingError } from '../models'
 import {
     MetadataCategory,
     PopulatedWorkflowData,
@@ -6,22 +7,14 @@ import {
     QuestionData,
     SelectedAnswerData,
     SelectedAnswersData,
-    WorkflowAnswersMissingError,
     WorkflowData,
     WorkflowPageData,
     WorkflowUploadedImage,
-} from '../models'
+} from 'oro-sdk-apis'
 
 export async function filterTriggeredAnsweredWithKind(
     workflowData: WorkflowData,
-    kind:
-        | 'text'
-        | 'date'
-        | 'number'
-        | 'images'
-        | 'images-alias'
-        | 'body-parts'
-        | 'pharmacy-picker'
+    kind: 'text' | 'date' | 'number' | 'images' | 'images-alias' | 'body-parts' | 'pharmacy-picker'
 ): Promise<SelectedAnswerData[]> {
     if (!workflowData.selectedAnswers) throw WorkflowAnswersMissingError
 
@@ -32,11 +25,7 @@ export async function filterTriggeredAnsweredWithKind(
         workflowData.pages
             .map((a) => {
                 return Object.entries(a.questions).filter(
-                    ([_, question]) =>
-                        isTriggered(
-                            question.triggers || [],
-                            flattenedAnswers
-                        ) && question.kind === kind
+                    ([_, question]) => isTriggered(question.triggers || [], flattenedAnswers) && question.kind === kind
                 )
             })
             .flat()
@@ -46,11 +35,9 @@ export async function filterTriggeredAnsweredWithKind(
         return { ...prev, ...cur }
     }, {})
 
-    const res = Object.keys(triggeredQuestionsWithKind).map(
-        (questionFieldName) => {
-            return samePageAnswers[questionFieldName]
-        }
-    )
+    const res = Object.keys(triggeredQuestionsWithKind).map((questionFieldName) => {
+        return samePageAnswers[questionFieldName]
+    })
 
     return res
 }
@@ -90,17 +77,11 @@ export async function getWorkflowDataByCategory(
         workflowData.selectedAnswers
             .map((e) => Object.entries(e))
             .flat()
-            .filter(
-                ([k, v]) =>
-                    triggeredQuestions[k] &&
-                    triggeredQuestions[k]['metaCategory'] === category
-            )
+            .filter(([k, v]) => triggeredQuestions[k] && triggeredQuestions[k]['metaCategory'] === category)
             .map(([k, v]) => {
-                return populateWorkflowField(triggeredQuestions[k], v).then(
-                    (populatedValue) => {
-                        fields[k] = populatedValue
-                    }
-                )
+                return populateWorkflowField(triggeredQuestions[k], v).then((populatedValue) => {
+                    fields[k] = populatedValue
+                })
             })
     )
         .then(() => {
@@ -113,20 +94,13 @@ export async function getWorkflowDataByCategory(
             return ret
         })
         .catch((err) => {
-            console.error(
-                `Error while extracting ${category} data from workflow`,
-                err
-            )
+            console.error(`Error while extracting ${category} data from workflow`, err)
             throw err
         })
 }
 
-export async function getImagesFromIndexDb(
-    answer: SelectedAnswerData
-): Promise<WorkflowUploadedImage[]> {
-    return await getMany<WorkflowUploadedImage>(
-        (answer as any[]).map((v) => v.id ?? v) as string[]
-    )
+export async function getImagesFromIndexDb(answer: SelectedAnswerData): Promise<WorkflowUploadedImage[]> {
+    return await getMany<WorkflowUploadedImage>((answer as any[]).map((v) => v.id ?? v) as string[])
 }
 
 /**
@@ -212,37 +186,25 @@ export function flattenSelectedAnswers(answers: SelectedAnswersData) {
  * @param useDefault use workflow default values or not (this is used to avoid having unset values to appear in summaries)
  * @returns a valid selectedAnswers structure
  */
-export function getInitialisedSelectedAnswers(
-    workflow: WorkflowData,
-    useDefault: boolean = true
-) {
+export function getInitialisedSelectedAnswers(workflow: WorkflowData, useDefault: boolean = true) {
     return workflow.pages.map((page) => {
         const ret: any = {}
         for (const [id, question] of Object.entries(page.questions)) {
             if (question.kind === 'body-parts') {
                 ret[id] = useDefault ? [] : undefined
             } else {
-                ret[id] =
-                    useDefault && question.defaultValue
-                        ? question.defaultValue
-                        : undefined
+                ret[id] = useDefault && question.defaultValue ? question.defaultValue : undefined
             }
         }
         return ret
     })
 }
 
-export function fillWorkflowFromPopulatedWorkflow(
-    workflow: WorkflowData,
-    populatedWorkflow: PopulatedWorkflowData
-) {
+export function fillWorkflowFromPopulatedWorkflow(workflow: WorkflowData, populatedWorkflow: PopulatedWorkflowData) {
     const filledWorkflow = JSON.parse(JSON.stringify(workflow))
 
     if (!filledWorkflow.selectedAnswers) {
-        filledWorkflow.selectedAnswers = getInitialisedSelectedAnswers(
-            filledWorkflow,
-            false
-        )
+        filledWorkflow.selectedAnswers = getInitialisedSelectedAnswers(filledWorkflow, false)
     }
 
     filledWorkflow.pages.forEach((page: WorkflowPageData, pageIdx: number) => {
@@ -250,9 +212,9 @@ export function fillWorkflowFromPopulatedWorkflow(
         for (const [id] of Object.entries(page.questions)) {
             if (populatedWorkflow.fields[id]) {
                 if (filledWorkflow.selectedAnswers)
-                    filledWorkflow.selectedAnswers[pageIdx][
-                        id
-                    ] = populatedWorkflow.fields[id].answer as string | string[]
+                    filledWorkflow.selectedAnswers[pageIdx][id] = populatedWorkflow.fields[id].answer as
+                        | string
+                        | string[]
             }
         }
     })

package/src/index.ts

@@ -1,13 +1,4 @@
-import {
-    APIService,
-    TellerService,
-    VaultService,
-    GuardService,
-    PracticeService,
-    ConsultService,
-    WorkflowService,
-    DiagnosisService,
-} from './services'
+import initApis from 'oro-sdk-apis'
 import { OroClient } from './client'
 import * as OroToolboxNamespace from 'oro-toolbox'
 
@@ -15,6 +6,19 @@ export type OroToolbox = typeof OroToolboxNamespace
 
 export let wasmPath = 'node_modules/oro-toolbox'
 
+/**
+ * This function helps you to initialize and OroClient instance
+ * @param toolbox the OroToolbox object
+ * @param tellerBaseURL the teller service base URL 
+ * @param vaultBaseURL the vault service base URL 
+ * @param guardBaseURL the guard service base URL 
+ * @param practiceBaseURL the practice service base URL 
+ * @param consultBaseURL the consult service base URL 
+ * @param workflowBaseURL the workflow service base URL 
+ * @param diagnosisBaseURL the diagnosis service base URL 
+ * @param authenticationCallback (optional) authenticationCallback the authentification callback 
+ * @returns an instance of OroClient
+ */
 const init = (
     toolbox: OroToolbox,
     tellerBaseURL: string,
@@ -23,30 +27,39 @@ const init = (
     practiceBaseURL: string,
     consultBaseURL: string,
     workflowBaseURL: string,
-    diagnosisBaseUrl: string,
-    authenticationCallback?: (err: Error) => void,
+    diagnosisBaseURL: string,
+    authenticationCallback?: (err: Error) => void
 ) => {
-    const apiService = new APIService(undefined, authenticationCallback)
-    const tellerService = new TellerService(apiService, tellerBaseURL)
-    const practiceService = new PracticeService(
-        toolbox,
-        apiService,
-        practiceBaseURL
-    )
-    const consultService = new ConsultService(apiService, consultBaseURL)
-    const vaultService = new VaultService(apiService, vaultBaseURL)
-    const guardService = new GuardService(apiService, guardBaseURL)
-    const workflowService = new WorkflowService(apiService, workflowBaseURL)
-    const diagnosisService = new DiagnosisService(apiService, diagnosisBaseUrl)
-    const client = new OroClient(
-        toolbox,
+    const {
         tellerService,
-        vaultService,
-        guardService,
         practiceService,
         consultService,
+        vaultService,
+        guardService,
         workflowService,
         diagnosisService,
+    } = initApis(
+        {
+            tellerBaseURL,
+            vaultBaseURL,
+            guardBaseURL,
+            practiceBaseURL,
+            consultBaseURL,
+            workflowBaseURL,
+            diagnosisBaseURL,
+        },
+        authenticationCallback
+    )
+
+    const client = new OroClient(
+        toolbox,
+        tellerService!,
+        vaultService!,
+        guardService!,
+        practiceService!,
+        consultService!,
+        workflowService!,
+        diagnosisService!,
         authenticationCallback
     )
 
@@ -54,6 +67,7 @@ const init = (
 }
 
 export { OroClient } from './client'
+export * from 'oro-sdk-apis'
 export * from './models'
 export * from './helpers'
 export * from './services'

package/src/models/client.ts

@@ -1,5 +1,5 @@
 import { PlaceData } from '../services/external/clinia'
-import { Uuid } from './shared'
+import { Uuid } from 'oro-sdk-apis'
 
 export interface PersonalInformations {
     birthday?: string