@icure/api 6.2.1 → 6.3.1

package/icc-x-api/icc-patient-x-api.d.ts

@@ -45,6 +45,10 @@ export declare class IccPatientXApi extends IccPatientApi {
     getPatient(patientId: string): never;
     getPatientRaw(patientId: string): Promise<models.Patient | any>;
     getPatientWithUser(user: models.User, patientId: string): Promise<models.Patient | any>;
+    getPotentiallyEncryptedPatientWithUser(user: models.User, patientId: string): Promise<{
+        patient: models.Patient;
+        decrypted: boolean;
+    }>;
     getPatients(body?: models.ListOfIds): never;
     getPatientsWithUser(user: models.User, body?: models.ListOfIds): Promise<Array<models.Patient> | any>;
     listDeletedPatients(startDate?: number, endDate?: number, desc?: boolean, startDocumentId?: string, limit?: number): never;
@@ -69,7 +73,9 @@ export declare class IccPatientXApi extends IccPatientApi {
     modifyPatientReferral(patientId: string, referralId: string, start?: number, end?: number): never;
     modifyPatientReferralWithUser(user: models.User, patientId: string, referralId: string, start?: number, end?: number): Promise<models.Patient | any>;
     encrypt(user: models.User, pats: Array<models.Patient>): Promise<Array<models.Patient>>;
+    private tryEncrypt;
     decrypt(user: models.User, patients: Array<models.Patient>, fillDelegations?: boolean): Promise<Array<models.Patient>>;
+    private tryDecryptOrReturnOriginal;
     /** By default, an encryptionKey will be added for every hcp in the autoDelegations of the provided user.
      * In optional field additionalDelegateIds, you can ask the method to create encryptionKeys for additional hcps */
     initEncryptionKeys(user: models.User, pat: models.Patient, additionalDelegateIds?: string[]): Promise<models.Patient>;

package/icc-x-api/icc-patient-x-api.js

@@ -79,13 +79,23 @@ class IccPatientXApi extends icc_api_1.IccPatientApi {
     }
     initDelegationsAndEncryptionKeys(patient, user, secretForeignKey = undefined, delegates = []) {
         return __awaiter(this, void 0, void 0, function* () {
+            function updatePatientWithDataOwnerIfSame(dataOwner) {
+                if (dataOwner.id === patient.id) {
+                    _.extend(patient, {
+                        rev: dataOwner.rev,
+                        publicKey: dataOwner.publicKey,
+                        aesExchangeKeys: dataOwner.aesExchangeKeys,
+                        hcPartyKeys: dataOwner.hcPartyKeys
+                    });
+                }
+            }
             const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user);
             const dels = yield this.crypto.initObjectDelegations(patient, null, dataOwnerId, null);
+            updatePatientWithDataOwnerIfSame(dels.owner);
             const eks = yield this.crypto.initEncryptionKeys(patient, dataOwnerId);
-            _.extend(patient, {
-                delegations: dels.delegations,
-                encryptionKeys: eks.encryptionKeys,
-            });
+            updatePatientWithDataOwnerIfSame(eks.modifiedOwner);
+            patient.delegations = dels.delegations;
+            patient.encryptionKeys = eks.encryptionKeys;
             let promise = Promise.resolve(patient);
             _.uniq(delegates.concat(user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : [])).forEach((delegateId) => (promise = promise.then((patient) => this.crypto.addDelegationsAndEncryptionKeys(null, patient, dataOwnerId, delegateId, dels.secretId, eks.secretId).catch((e) => {
                 console.log(e);
@@ -183,7 +193,13 @@ class IccPatientXApi extends icc_api_1.IccPatientApi {
     getPatientWithUser(user, patientId) {
         return super
             .getPatient(patientId)
-            .then((p) => this.decrypt(user, [p]))
+            .then((p) => this.tryDecryptOrReturnOriginal(user, [p], false))
+            .then((pats) => pats[0].patient);
+    }
+    getPotentiallyEncryptedPatientWithUser(user, patientId) {
+        return super
+            .getPatient(patientId)
+            .then((p) => this.tryDecryptOrReturnOriginal(user, [p], false))
             .then((pats) => pats[0]);
     }
     getPatients(body) {
@@ -261,7 +277,7 @@ class IccPatientXApi extends icc_api_1.IccPatientApi {
     }
     modifyPatientWithUser(user, body) {
         return body
-            ? this.encrypt(user, [_.cloneDeep(this.completeNames(body))])
+            ? this.tryEncrypt(user, [_.cloneDeep(this.completeNames(body))], false)
                 .then((pats) => super.modifyPatient(pats[0]))
                 .then((p) => this.decrypt(user, [p]))
                 .then((pats) => {
@@ -285,36 +301,43 @@ class IccPatientXApi extends icc_api_1.IccPatientApi {
         });
     }
     encrypt(user, pats) {
+        return this.tryEncrypt(user, pats, true);
+    }
+    tryEncrypt(user, pats, requireAccessibleKey) {
         const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user);
-        const fixEncryptionKeys = (p) => {
-            if (p.delegations && p.delegations[dataOwnerId])
-                return this.initEncryptionKeys(user, p, Object.keys(p.delegations));
-            else
-                throw new Error(`Patient ${p.id} has no delegation or encryption key for hcp ${dataOwnerId}`);
-        };
-        return Promise.all(pats.map((p) => (p.encryptionKeys && Object.keys(p.encryptionKeys).some((k) => !!p.encryptionKeys[k].length)
-            ? Promise.resolve(p)
-            : this.initEncryptionKeys(user, p))
-            .then((p) => __awaiter(this, void 0, void 0, function* () {
-            try {
-                const seks = yield this.crypto.extractKeysFromDelegationsForHcpHierarchy(dataOwnerId, p.id, p.encryptionKeys);
-                return seks;
+        return Promise.all(pats.map((p) => __awaiter(this, void 0, void 0, function* () {
+            const patientWithInitialisedEks = (p.encryptionKeys && Object.values(p.encryptionKeys).some((v) => !!v.length)
+                ? p
+                : yield this.initEncryptionKeys(user, p));
+            const seks = yield this.crypto.extractKeysFromDelegationsForHcpHierarchy(dataOwnerId, patientWithInitialisedEks.id, patientWithInitialisedEks.encryptionKeys).catch((e) => { console.error(e); throw e; });
+            if (seks.extractedKeys.length) {
+                const key = yield this.crypto.AES.importKey('raw', (0, binary_utils_1.hex2ua)(seks.extractedKeys[0].replace(/-/g, '')));
+                return (0, utils_1.crypt)(patientWithInitialisedEks, (obj) => this.crypto.AES.encrypt(key, (0, binary_utils_1.utf8_2ua)(JSON.stringify(obj, (k, v) => {
+                    return v instanceof ArrayBuffer || v instanceof Uint8Array
+                        ? (0, binary_utils_1.b2a)(new Uint8Array(v).reduce((d, b) => d + String.fromCharCode(b), ''))
+                        : v;
+                }))), this.encryptedKeys);
             }
-            catch (e) {
-                console.error(e);
-                throw e;
+            else if (requireAccessibleKey) {
+                throw new Error(`Current data owner can't access any key of patient ${p.id}.`);
             }
-        }))
-            .then((seks) => this.crypto.AES.importKey('raw', (0, binary_utils_1.hex2ua)(seks.extractedKeys[0].replace(/-/g, ''))))
-            .then((key) => (0, utils_1.crypt)(p, (obj) => this.crypto.AES.encrypt(key, (0, binary_utils_1.utf8_2ua)(JSON.stringify(obj, (k, v) => {
-            return v instanceof ArrayBuffer || v instanceof Uint8Array
-                ? (0, binary_utils_1.b2a)(new Uint8Array(v).reduce((d, b) => d + String.fromCharCode(b), ''))
-                : v;
-        }))), this.encryptedKeys))));
+            else {
+                const cryptedCopyWithRandomKey = yield (0, utils_1.crypt)(_.cloneDeep(patientWithInitialisedEks), (obj) => __awaiter(this, void 0, void 0, function* () { return Promise.resolve(new ArrayBuffer(1)); }), this.encryptedKeys);
+                if (!_.isEqual(_.omitBy(Object.assign(Object.assign({}, cryptedCopyWithRandomKey), { encryptedSelf: undefined }), _.isNil), _.omitBy(Object.assign(Object.assign({}, patientWithInitialisedEks), { encryptedSelf: undefined }), _.isNil))) {
+                    throw Error("You can't modify encrypted data of a patient if you don't have access to his encryption key.");
+                }
+                return patientWithInitialisedEks;
+            }
+        })));
     }
+    // If patient can't be decrypted returns patient with encrypted data.
     decrypt(user, patients, fillDelegations = true) {
-        const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user);
-        return (user.healthcarePartyId ? this.hcpartyApi.getHealthcarePartyHierarchyIds(user.healthcarePartyId) : Promise.resolve([dataOwnerId])).then((ids) => __awaiter(this, void 0, void 0, function* () {
+        return this.tryDecryptOrReturnOriginal(user, patients, fillDelegations).then((ps) => ps.map((p) => p.patient));
+    }
+    tryDecryptOrReturnOriginal(user, patients, fillDelegations = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user);
+            const ids = yield (user.healthcarePartyId ? this.hcpartyApi.getHealthcarePartyHierarchyIds(user.healthcarePartyId) : Promise.resolve([dataOwnerId]));
             //First check that we have no dangling delegation
             const patsWithMissingDelegations = patients.filter((p) => p.delegations &&
                 ids.some((id) => p.delegations[id] && !p.delegations[id].length) &&
@@ -330,10 +353,9 @@ class IccPatientXApi extends icc_api_1.IccPatientApi {
             return Promise.all(patients
                 .map((p) => acc[p.id] || p)
                 .map((p) => __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                return ((_a = (yield ids.reduce((decP, hcpId) => __awaiter(this, void 0, void 0, function* () {
-                    var _b;
-                    return ((_b = (yield decP)) !== null && _b !== void 0 ? _b : (p.encryptedSelf
+                const decryptedPatient = yield ids.reduce((decP, hcpId) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    return ((_a = (yield decP)) !== null && _a !== void 0 ? _a : (p.encryptedSelf
                         ? yield this.crypto
                             .extractKeysFromDelegationsForHcpHierarchy(hcpId, p.id, _.size(p.encryptionKeys) ? p.encryptionKeys : p.delegations)
                             .then(({ extractedKeys: sfks }) => {
@@ -362,9 +384,10 @@ class IccPatientXApi extends icc_api_1.IccPatientApi {
                             }));
                         })
                         : p));
-                }), Promise.resolve(undefined)))) !== null && _a !== void 0 ? _a : p);
+                }), Promise.resolve(undefined));
+                return decryptedPatient ? { patient: decryptedPatient, decrypted: true } : { patient: p, decrypted: false };
             })));
-        }));
+        });
     }
     /** By default, an encryptionKey will be added for every hcp in the autoDelegations of the provided user.
      * In optional field additionalDelegateIds, you can ask the method to create encryptionKeys for additional hcps */
@@ -372,7 +395,7 @@ class IccPatientXApi extends icc_api_1.IccPatientApi {
         const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user);
         const userAutoDelegations = user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : [];
         return this.crypto.initEncryptionKeys(pat, dataOwnerId).then((eks) => {
-            let promise = Promise.resolve(_.extend(pat, {
+            let promise = Promise.resolve(_.extend(pat.id === eks.modifiedOwner.id ? eks.modifiedOwner : pat, {
                 encryptionKeys: eks.encryptionKeys,
             }));
             new Set([...userAutoDelegations, ...(additionalDelegateIds || [])]).forEach((delegateId) => (promise = promise.then((patient) => this.crypto