@icure/api 8.4.3 → 8.4.5

package/icc-x-api/icc-form-x-api.ts

@@ -1,293 +0,0 @@
-import { IccFormApi } from '../icc-api'
-import { IccCryptoXApi } from './icc-crypto-x-api'
-
-import * as _ from 'lodash'
-import * as models from '../icc-api/model/models'
-
-import { IccDataOwnerXApi } from './icc-data-owner-x-api'
-import { AuthenticationProvider, NoAuthenticationProvider } from './auth/AuthenticationProvider'
-import { SecureDelegation } from '../icc-api/model/SecureDelegation'
-import AccessLevelEnum = SecureDelegation.AccessLevelEnum
-import { ShareMetadataBehaviour } from './crypto/ShareMetadataBehaviour'
-import { ShareResult } from './utils/ShareResult'
-import { EntityShareRequest } from '../icc-api/model/requests/EntityShareRequest'
-import RequestedPermissionEnum = EntityShareRequest.RequestedPermissionEnum
-import { XHR } from '../icc-api/api/XHR'
-import { EncryptedEntityXApi } from './basexapi/EncryptedEntityXApi'
-import { EntityWithDelegationTypeName } from './utils'
-import { SecretIdUseOption } from './crypto/SecretIdUseOption'
-
-// noinspection JSUnusedGlobalSymbols
-export class IccFormXApi extends IccFormApi implements EncryptedEntityXApi<models.Form> {
-  crypto: IccCryptoXApi
-  dataOwnerApi: IccDataOwnerXApi
-
-  get headers(): Promise<Array<XHR.Header>> {
-    return super.headers.then((h) => this.crypto.accessControlKeysHeaders.addAccessControlKeysHeaders(h, EntityWithDelegationTypeName.Form))
-  }
-
-  constructor(
-    host: string,
-    headers: { [key: string]: string },
-    crypto: IccCryptoXApi,
-    dataOwnerApi: IccDataOwnerXApi,
-    private readonly autofillAuthor: boolean,
-    authenticationProvider: AuthenticationProvider = new NoAuthenticationProvider(),
-    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
-      ? window.fetch
-      : typeof self !== 'undefined'
-      ? self.fetch
-      : fetch
-  ) {
-    super(host, headers, authenticationProvider, fetchImpl)
-    this.crypto = crypto
-    this.dataOwnerApi = dataOwnerApi
-  }
-
-  /**
-   * Creates a new instance of form with initialised encryption metadata (not in the database).
-   * @param user the current user.
-   * @param patient the patient this form refers to.
-   * @param c initialised data for the form. Metadata such as id, creation data, etc. will be automatically initialised, but you can specify
-   * other kinds of data or overwrite generated metadata with this. You can't specify encryption metadata.
-   * @param options optional parameters:
-   * - additionalDelegates: delegates which will have access to the entity in addition to the current data owner and delegates from the
-   * auto-delegations. Must be an object which associates each data owner id with the access level to give to that data owner. May overlap with
-   * auto-delegations, in such case the access level specified here will be used.
-   * - sfkOption: specifies which sfk of the owning entity to use.
-   * - ignoreAutoDelegations: if true the data won't be shared with the autodelegations of the user, but only with additional delegates
-   * - alternateRootDelegation: by default a new entity is created with a root delegation from self to self. In keyless mode this is not possible,
-   * and instead the root delegation will be from self to another. You have to specify which delegate will be part of the root delegation.
-   * @return a new instance of form.
-   */
-  async newInstance(
-    user: models.User,
-    patient: models.Patient,
-    c: any = {},
-    options: {
-      additionalDelegates?: { [dataOwnerId: string]: AccessLevelEnum }
-      sfkOption?: SecretIdUseOption
-      ignoreAutoDelegations?: boolean
-      alternateRootDelegation?: string
-    } = {}
-  ) {
-    const form = {
-      ...(c ?? {}),
-      _type: 'org.taktik.icure.entities.Form',
-      id: c?.id ?? this.crypto.primitives.randomUuid(),
-      created: c?.created ?? new Date().getTime(),
-      modified: c?.modified ?? new Date().getTime(),
-      responsible: c?.responsible ?? (this.autofillAuthor ? this.dataOwnerApi.getDataOwnerIdOf(user) : undefined),
-      author: c?.author ?? (this.autofillAuthor ? user.id : undefined),
-      codes: c?.codes ?? [],
-      tags: c?.tags ?? [],
-    }
-
-    const ownerId = this.dataOwnerApi.getDataOwnerIdOf(user)
-    if (ownerId !== (await this.dataOwnerApi.getCurrentDataOwnerId())) throw new Error('Can only initialise entities as current data owner.')
-    const sfk = await this.crypto.xapi.resolveSecretIdUseOptions(
-      { entity: patient, type: EntityWithDelegationTypeName.Patient },
-      options.sfkOption ?? SecretIdUseOption.UseAnySharedWithParent
-    )
-    const extraDelegations = {
-      ...(options.ignoreAutoDelegations == true
-        ? {}
-        : Object.fromEntries(
-            [...(user.autoDelegations?.all ?? []), ...(user.autoDelegations?.medicalInformation ?? [])].map((d) => [d, AccessLevelEnum.WRITE])
-          )),
-      ...(options?.additionalDelegates ?? {}),
-    }
-    return new models.Form(
-      await this.crypto.xapi
-        .entityWithInitialisedEncryptedMetadata(
-          form,
-          EntityWithDelegationTypeName.Form,
-          patient.id,
-          sfk,
-          true,
-          extraDelegations,
-          options.alternateRootDelegation
-        )
-        .then((x) => x.updatedEntity)
-    )
-  }
-
-  // noinspection JSUnusedGlobalSymbols
-  /**
-   * 1. Check whether there is a delegation with 'hcpartyId' or not.
-   * 2. 'fetchHcParty[hcpartyId][1]': is encrypted AES exchange key by RSA public key of him.
-   * 3. Obtain the AES exchange key, by decrypting the previous step value with hcparty private key
-   *      3.1.  KeyPair should be fetch from cache (in jwk)
-   *      3.2.  if it doesn't exist in the cache, it has to be loaded from Browser Local store, and then import it to WebCrypto
-   * 4. Obtain the array of delegations which are delegated to his ID (hcpartyId) in this patient
-   * 5. Decrypt and collect all keys (secretForeignKeys) within delegations of previous step (with obtained AES key of step 4)
-   * 6. Do the REST call to get all contacts with (allSecretForeignKeysDelimitedByComa, hcpartyId)
-   *
-   * After these painful steps, you have the contacts of the patient.
-   * @deprecated use {@link findIdsBy} instead.
-   * @param hcpartyId
-   * @param patient
-   * @param usingPost (Promise)
-   */
-  async findBy(hcpartyId: string, patient: models.Patient, usingPost: boolean = false) {
-    const extractedKeys = await this.crypto.xapi.secretIdsOf({ entity: patient, type: EntityWithDelegationTypeName.Patient }, hcpartyId)
-    const topmostParentId = (await this.dataOwnerApi.getCurrentDataOwnerHierarchyIds())[0]
-    let forms: Array<models.Form> = await (usingPost
-      ? this.findFormsByHCPartyPatientForeignKeysUsingPost(hcpartyId!, undefined, undefined, undefined, _.uniq(extractedKeys))
-      : this.findFormsByHCPartyPatientForeignKeys(hcpartyId!, _.uniq(extractedKeys).join(',')))
-    return await this.decrypt(hcpartyId, forms)
-  }
-
-  /**
-   * Same as {@link findBy} but it will only return the ids of the forms. It can also filter the forms where Form.openingDate is between
-   * startDate and endDate in ascending or descending order by that field. (default: ascending).
-   */
-  async findIdsBy(hcpartyId: string, patient: models.Patient, startDate?: number, endDate?: number, descending?: boolean) {
-    const extractedKeys = await this.crypto.xapi.secretIdsOf({ entity: patient, type: EntityWithDelegationTypeName.Patient }, hcpartyId)
-    return this.findFormIdsByDataOwnerPatientOpeningDate(hcpartyId, _.uniq(extractedKeys), startDate, endDate, descending)
-  }
-
-  async decrypt(hcpartyId: string, forms: Array<models.Form>) {
-    return (await this.crypto.xapi.tryDecryptEntities(forms, EntityWithDelegationTypeName.Form, (x) => new models.Form(x))).map(
-      ({ entity }) => entity
-    )
-  }
-
-  /**
-   * @param form a form
-   * @return the id of the patient that the form refers to, retrieved from the encrypted metadata. Normally there should only be one element
-   * in the returned array, but in case of entity merges there could be multiple values.
-   */
-  async decryptPatientIdOf(form: models.Form): Promise<string[]> {
-    return this.crypto.xapi.owningEntityIdsOf({ entity: form, type: EntityWithDelegationTypeName.Form }, undefined)
-  }
-
-  /**
-   * @return if the logged data owner has write access to the content of the given form
-   */
-  async hasWriteAccess(form: models.Form): Promise<boolean> {
-    return this.crypto.xapi.hasWriteAccess({ entity: form, type: EntityWithDelegationTypeName.Form })
-  }
-
-  /**
-   * Share an existing form with other data owners, allowing them to access the non-encrypted data of the form and optionally also
-   * the encrypted content, with read-only or read-write permissions.
-   * @param delegateId the id of the data owner which will be granted access to the form.
-   * @param form the form to share.
-   * @param options optional parameters to customize the sharing behaviour:
-   * - shareSecretIds: specifies which secret ids of the entity should be shared. If not provided all secret ids available to the current user will be shared
-   * - shareEncryptionKey: specifies if the encryption key of the access log should be shared with the delegate, giving access to all encrypted
-   * content of the entity, excluding other encrypted metadata (defaults to {@link ShareMetadataBehaviour.IF_AVAILABLE}). Note that by default a
-   * form does not have encrypted content.
-   * - sharePatientId: specifies if the id of the patient that this form refers to should be shared with the delegate (defaults to
-   * {@link ShareMetadataBehaviour.IF_AVAILABLE}).
-   * - requestedPermissions: the requested permissions for the delegate, defaults to {@link RequestedPermissionEnum.MAX_WRITE}.
-   * @return the updated entity
-   */
-  async shareWith(
-    delegateId: string,
-    form: models.Form,
-    options: {
-      shareSecretIds?: string[]
-      requestedPermissions?: RequestedPermissionEnum
-      shareEncryptionKey?: ShareMetadataBehaviour // Defaults to ShareMetadataBehaviour.IF_AVAILABLE
-      sharePatientId?: ShareMetadataBehaviour // Defaults to ShareMetadataBehaviour.IF_AVAILABLE
-    } = {}
-  ): Promise<models.Form> {
-    return this.shareWithMany(form, { [delegateId]: options })
-  }
-
-  /**
-   * Share an existing form with other data owners, allowing them to access the non-encrypted data of the form and optionally also
-   * the encrypted content, with read-only or read-write permissions.
-   * @param form the form to share.
-   * @param delegates associates the id of data owners which will be granted access to the entity, to the following sharing options:
-   * - shareSecretIds: specifies which secret ids of the entity should be shared. If not provided all secret ids available to the current user will be shared
-   * - shareEncryptionKey: specifies if the encryption key of the access log should be shared with the delegate, giving access to all encrypted
-   * content of the entity, excluding other encrypted metadata (defaults to {@link ShareMetadataBehaviour.IF_AVAILABLE}). Note that by default a
-   * form does not have encrypted content.
-   * - sharePatientId: specifies if the id of the patient that this form refers to should be shared with the delegate (defaults to
-   * {@link ShareMetadataBehaviour.IF_AVAILABLE}).
-   * - requestedPermissions: the requested permissions for the delegate, defaults to {@link RequestedPermissionEnum.MAX_WRITE}.
-   * @return the updated entity
-   */
-  async shareWithMany(
-    form: models.Form,
-    delegates: {
-      [delegateId: string]: {
-        shareSecretIds?: string[]
-        requestedPermissions?: RequestedPermissionEnum
-        shareEncryptionKey?: ShareMetadataBehaviour // Defaults to ShareMetadataBehaviour.IF_AVAILABLE
-        sharePatientId?: ShareMetadataBehaviour // Defaults to ShareMetadataBehaviour.IF_AVAILABLE
-      }
-    }
-  ): Promise<models.Form> {
-    return (await this.tryShareWithMany(form, delegates)).updatedEntityOrThrow
-  }
-
-  /**
-   * Share an existing form with other data owners, allowing them to access the non-encrypted data of the form and optionally also
-   * the encrypted content, with read-only or read-write permissions.
-   * @param form the form to share.
-   * @param delegates associates the id of data owners which will be granted access to the entity, to the following sharing options:
-   * - shareSecretIds: specifies which secret ids of the entity should be shared. If not provided all secret ids available to the current user will be shared
-   * - shareEncryptionKey: specifies if the encryption key of the access log should be shared with the delegate, giving access to all encrypted
-   * content of the entity, excluding other encrypted metadata (defaults to {@link ShareMetadataBehaviour.IF_AVAILABLE}). Note that by default a
-   * form does not have encrypted content.
-   * - sharePatientId: specifies if the id of the patient that this form refers to should be shared with the delegate (defaults to
-   * {@link ShareMetadataBehaviour.IF_AVAILABLE}).
-   * - requestedPermissions: the requested permissions for the delegate, defaults to {@link RequestedPermissionEnum.MAX_WRITE}.
-   * @return a promise which will contain the result of the operation: the updated entity if the operation was successful or details of the error if
-   * the operation failed.
-   */
-  async tryShareWithMany(
-    form: models.Form,
-    delegates: {
-      [delegateId: string]: {
-        shareSecretIds?: string[]
-        requestedPermissions?: RequestedPermissionEnum
-        shareEncryptionKey?: ShareMetadataBehaviour // Defaults to ShareMetadataBehaviour.IF_AVAILABLE
-        sharePatientId?: ShareMetadataBehaviour // Defaults to ShareMetadataBehaviour.IF_AVAILABLE
-      }
-    }
-  ): Promise<ShareResult<models.Form>> {
-    const self = await this.dataOwnerApi.getCurrentDataOwnerId()
-    // All entities should have an encryption key.
-    const entityWithEncryptionKey = await this.crypto.xapi.ensureEncryptionKeysInitialised(form, EntityWithDelegationTypeName.Form)
-    const updatedEntity = entityWithEncryptionKey ? await this.modifyForm(entityWithEncryptionKey) : form
-    return this.crypto.xapi
-      .simpleShareOrUpdateEncryptedEntityMetadata(
-        {
-          entity: updatedEntity,
-          type: EntityWithDelegationTypeName.Form,
-        },
-        Object.fromEntries(
-          Object.entries(delegates).map(([delegateId, options]) => [
-            delegateId,
-            {
-              requestedPermissions: options.requestedPermissions,
-              shareEncryptionKeys: options.shareEncryptionKey,
-              shareOwningEntityIds: options.sharePatientId,
-              shareSecretIds: options.shareSecretIds,
-            },
-          ])
-        ),
-        (x) => this.bulkShareForms(x)
-      )
-      .then((r) => r.mapSuccessAsync((e) => this.decrypt(self, [e]).then((es) => es[0])))
-  }
-
-  getDataOwnersWithAccessTo(
-    entity: models.Form
-  ): Promise<{ permissionsByDataOwnerId: { [p: string]: AccessLevelEnum }; hasUnknownAnonymousDataOwners: boolean }> {
-    return this.crypto.delegationsDeAnonymization.getDataOwnersWithAccessTo({ entity, type: EntityWithDelegationTypeName.Form })
-  }
-
-  getEncryptionKeysOf(entity: models.Form): Promise<string[]> {
-    return this.crypto.xapi.encryptionKeysOf({ entity, type: EntityWithDelegationTypeName.Form }, undefined)
-  }
-
-  createDelegationDeAnonymizationMetadata(entity: models.Form, delegates: string[]): Promise<void> {
-    return this.crypto.delegationsDeAnonymization.createOrUpdateDeAnonymizationInfo({ entity, type: EntityWithDelegationTypeName.Form }, delegates)
-  }
-}

package/icc-x-api/icc-hcparty-x-api.ts

@@ -1,189 +0,0 @@
-import { IccAuthApi, IccHcpartyApi } from '../icc-api'
-import { HealthcareParty } from '../icc-api/model/HealthcareParty'
-import * as models from '../icc-api/model/models'
-import { findName, garnishPersonWithName, hasName } from './utils/person-util'
-import { AuthenticationProvider, NoAuthenticationProvider } from './auth/AuthenticationProvider'
-import { AbstractFilter } from './filters/filters'
-import { subscribeToEntityEvents, SubscriptionOptions } from './utils'
-import { Connection, ConnectionImpl } from '../icc-api/model/Connection'
-import { ListOfIds } from '../icc-api/model/models'
-import { XHR } from '../icc-api/api/XHR'
-import XHRError = XHR.XHRError
-
-// noinspection JSUnusedGlobalSymbols
-export class IccHcpartyXApi extends IccHcpartyApi {
-  hcPartyKeysCache: { [key: string]: { [key: string]: string } } = {}
-  hcPartyCache: { [key: string]: [number, Promise<HealthcareParty>] } = {}
-
-  private CACHE_RETENTION_IN_MS = 300_000
-  constructor(
-    host: string,
-    headers: { [key: string]: string },
-    authenticationProvider: AuthenticationProvider = new NoAuthenticationProvider(),
-    private readonly authApi: IccAuthApi,
-    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
-      ? window.fetch
-      : typeof self !== 'undefined'
-      ? self.fetch
-      : fetch
-  ) {
-    super(host, headers, authenticationProvider, fetchImpl)
-  }
-
-  private getHcPartyFromCache(key: string) {
-    const hcpInCache = this.hcPartyCache[key]
-    const now = Date.now()
-    if (hcpInCache && hcpInCache[0] > now) {
-      return hcpInCache[1]
-    }
-    if (!hcpInCache) {
-      console.log(`Cache miss for key ${key} because not in cache`)
-    } else {
-      console.log(`Cache miss for key ${key} because ${hcpInCache[0]} > ${now}`)
-    }
-    return null
-  }
-
-  completeNames(hcParty?: models.HealthcareParty): models.HealthcareParty | undefined {
-    if (!hcParty) {
-      return hcParty
-    }
-
-    let finalHcParty = hcParty
-
-    if ((!!finalHcParty.lastName || !!finalHcParty.name) && !hasName(finalHcParty, models.PersonName.UseEnum.Official)) {
-      finalHcParty = garnishPersonWithName(
-        finalHcParty,
-        models.PersonName.UseEnum.Official,
-        finalHcParty.lastName,
-        finalHcParty.firstName,
-        finalHcParty.name
-      )
-    }
-
-    if ((!finalHcParty.lastName || !finalHcParty.name) && !!hasName(finalHcParty, models.PersonName.UseEnum.Official)) {
-      let officialName = findName(finalHcParty, models.PersonName.UseEnum.Official)
-      finalHcParty = {
-        ...finalHcParty,
-        lastName: officialName!.lastName,
-        firstName: officialName!.firstNames ? officialName!.firstNames[0] : undefined,
-        name: officialName!.text,
-      }
-    }
-
-    return finalHcParty
-  }
-
-  putHcPartyInCache(key: string, hcpPromise: Promise<HealthcareParty>): Promise<HealthcareParty> {
-    this.hcPartyCache[key] = [Date.now() + this.CACHE_RETENTION_IN_MS, hcpPromise]
-    return hcpPromise
-  }
-
-  createHealthcareParty(body?: HealthcareParty): Promise<HealthcareParty> {
-    return super.createHealthcareParty(this.completeNames(body))
-  }
-
-  createHealthcarePartyInGroup(groupId: string, body?: HealthcareParty): Promise<HealthcareParty> {
-    return super.createHealthcarePartyInGroup(groupId, this.completeNames(body))
-  }
-
-  modifyHealthcareParty(body?: HealthcareParty): Promise<HealthcareParty | any> {
-    if (body && body.id) {
-      console.log(`Evict key ${body.id} because of modification`)
-      delete this.hcPartyCache[body.id]
-    }
-
-    return super.modifyHealthcareParty(this.completeNames(body)).then((hcp) => this.putHcPartyInCache(hcp.id!, Promise.resolve(hcp)))
-  }
-
-  async getHealthcareParty(healthcarePartyId: string, bypassCache = false): Promise<HealthcareParty | any> {
-    const fromCache = bypassCache ? undefined : this.getHcPartyFromCache(healthcarePartyId)
-    if (fromCache) {
-      try {
-        return await fromCache
-      } catch {
-        if (this.hcPartyCache[healthcarePartyId][1] === fromCache) {
-          delete this.hcPartyCache[healthcarePartyId]
-        }
-        return this.getHealthcareParty(healthcarePartyId, bypassCache)
-      }
-    } else {
-      return await this.putHcPartyInCache(healthcarePartyId, super.getHealthcareParty(healthcarePartyId))
-    }
-  }
-
-  getHealthcarePartyHierarchyIds(healthcarePartyId: string, bypassCache = false): Promise<string[]> {
-    return this.getHealthcareParty(healthcarePartyId, bypassCache).then(async (hcp: HealthcareParty) => {
-      return hcp ? (hcp.parentId ? (await this.getHealthcarePartyHierarchyIds(hcp.parentId!, bypassCache)).concat([hcp.id!]) : [hcp.id!]) : []
-    })
-  }
-
-  async getHealthcareParties(healthcarePartyIds: ListOfIds): Promise<Array<HealthcareParty> | any> {
-    const ids = healthcarePartyIds.ids
-    if (!ids || !ids.length) {
-      return Promise.resolve([])
-    }
-    const cached: Array<[string, HealthcareParty | null]> = []
-    for (const id of ids) {
-      let hcp
-      try {
-        hcp = await this.getHcPartyFromCache(id)
-      } catch {
-        hcp = null
-        delete this.hcPartyCache[id]
-      }
-      cached.push([id, hcp])
-    }
-    const toFetch = cached.filter((x) => !x[1]).map((x) => x[0])
-
-    if (!toFetch.length) {
-      return Promise.all(cached.map((x) => x[1]!))
-    }
-
-    const prom: Promise<HealthcareParty[]> = super.getHealthcareParties(new ListOfIds({ ids: toFetch }))
-    return Promise.all(
-      cached.map(
-        (x) =>
-          x[1] ??
-          this.putHcPartyInCache(
-            x[0],
-            prom.then((hcps) => {
-              const hcp = hcps.find((h) => h.id === x[0])
-              if (!!hcp) {
-                return hcp
-              } else {
-                throw new Error(`Hcp with id ${x[0]} not found`)
-              }
-            })
-          ).catch((e) => {
-            if (e instanceof XHRError) {
-              throw e
-            }
-            return null
-          })
-      )
-    ).then((results) => results.filter((it) => it != null))
-  }
-
-  getCurrentHealthcareParty(): Promise<HealthcareParty> {
-    return super.getCurrentHealthcareParty().then((hcp) => this.putHcPartyInCache(hcp.id!, Promise.resolve(hcp)))
-  }
-
-  isValidCbe(cbe: string) {
-    cbe = cbe.replace(new RegExp('[^(0-9)]', 'g'), '')
-    cbe = cbe.length == 9 ? '0' + cbe : cbe
-
-    return 97 - (Number(cbe.substring(0, 8)) % 97) === Number(cbe.substring(8, 10))
-  }
-
-  async subscribeToHealthcarePartyEvents(
-    eventTypes: ('CREATE' | 'UPDATE' | 'DELETE')[],
-    filter: AbstractFilter<HealthcareParty> | undefined,
-    eventFired: (dataSample: HealthcareParty) => Promise<void>,
-    options: SubscriptionOptions = {}
-  ): Promise<Connection> {
-    return subscribeToEntityEvents(this.host, this.authApi, 'HealthcareParty', eventTypes, filter, eventFired, options).then(
-      (rs) => new ConnectionImpl(rs)
-    )
-  }
-}