@icure/api 7.1.34 → 7.1.35

package/test/utils/TestCryptoStrategies.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestCryptoStrategies = void 0;
+const RSA_1 = require("../../icc-x-api/crypto/RSA");
+const utils_1 = require("../../icc-x-api/crypto/utils");
+const crypto_1 = require("crypto");
+const icc_x_api_1 = require("../../icc-x-api");
+class TestCryptoStrategies {
+    constructor(keyPair, verifiedSelfKeys = {}, recoveredParentKeys = {}) {
+        this.recoveredParentKeys = recoveredParentKeys;
+        this.RSA = new RSA_1.RSAUtils(crypto_1.webcrypto);
+        this.recoverAndVerifyCallsParams = [];
+        this.keyPair = keyPair;
+        this.verifiedSelfKeys = verifiedSelfKeys;
+    }
+    generateNewKeyForDataOwner(self) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.keyPair)
+                return false;
+            const knownKeys = (0, utils_1.hexPublicKeysOf)(self.dataOwner);
+            const publicKey = (0, icc_x_api_1.ua2hex)(yield this.RSA.exportKey(this.keyPair.publicKey, 'spki'));
+            return knownKeys.has(publicKey) ? false : this.keyPair;
+        });
+    }
+    recoverAndVerifySelfHierarchyKeys(keysData, cryptoPrimitives) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.recoverAndVerifyCallsParams.push(keysData);
+            const self = keysData[keysData.length - 1].dataOwner;
+            const knownKeys = (0, utils_1.hexPublicKeysOf)(self.dataOwner);
+            const publicKey = this.keyPair ? (0, icc_x_api_1.ua2hex)(yield this.RSA.exportKey(this.keyPair.publicKey, 'spki')) : undefined;
+            return Object.fromEntries(yield Promise.all(keysData.map((currData) => __awaiter(this, void 0, void 0, function* () {
+                if (currData.dataOwner.dataOwner.id !== self.dataOwner.id) {
+                    const recoveredKey = this.recoveredParentKeys[currData.dataOwner.dataOwner.id];
+                    return [
+                        currData.dataOwner.dataOwner.id,
+                        {
+                            recoveredKeys: recoveredKey
+                                ? {
+                                    [recoveredKey.publicKey.slice(-32)]: yield cryptoPrimitives.RSA.importKeyPair('pkcs8', (0, icc_x_api_1.hex2ua)(recoveredKey.privateKey), 'spki', (0, icc_x_api_1.hex2ua)(recoveredKey.publicKey)),
+                                }
+                                : {},
+                            keyAuthenticity: {},
+                        },
+                    ];
+                }
+                else if (publicKey === undefined || !knownKeys.has(publicKey)) {
+                    return [currData.dataOwner.dataOwner.id, { recoveredKeys: {}, keyAuthenticity: this.verifiedSelfKeys }];
+                }
+                else {
+                    return [
+                        currData.dataOwner.dataOwner.id,
+                        { recoveredKeys: { [publicKey.slice(-32)]: this.keyPair }, keyAuthenticity: this.verifiedSelfKeys },
+                    ];
+                }
+            }))));
+        });
+    }
+    verifyDelegatePublicKeys(delegate, publicKeys) {
+        return Promise.resolve(publicKeys);
+    }
+}
+exports.TestCryptoStrategies = TestCryptoStrategies;
+//# sourceMappingURL=TestCryptoStrategies.js.map

package/test/utils/TestCryptoStrategies.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestCryptoStrategies.js","sourceRoot":"","sources":["../../../test/utils/TestCryptoStrategies.ts"],"names":[],"mappings":"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","sourcesContent":["import { CryptoStrategies } from '../../icc-x-api/crypto/CryptoStrategies'\nimport { KeyPair, RSAUtils } from '../../icc-x-api/crypto/RSA'\nimport { DataOwner } from '../../icc-x-api/icc-data-owner-x-api'\nimport { hexPublicKeysOf } from '../../icc-x-api/crypto/utils'\nimport { webcrypto } from 'crypto'\nimport { CryptoPrimitives, hex2ua, ua2hex } from '../../icc-x-api'\nimport { DataOwnerWithType } from '../../icc-api/model/DataOwnerWithType'\nimport { CryptoActorStubWithType } from '../../icc-api/model/CryptoActorStub'\n\nexport class TestCryptoStrategies implements CryptoStrategies {\n  private readonly keyPair: KeyPair<CryptoKey> | undefined\n  private readonly verifiedSelfKeys: { [p: string]: boolean }\n  private readonly RSA = new RSAUtils(webcrypto as any)\n  recoverAndVerifyCallsParams: Array<{ dataOwner: DataOwnerWithType; unknownKeys: string[]; unavailableKeys: string[] }[]> = []\n\n  constructor(\n    keyPair?: KeyPair<CryptoKey>,\n    verifiedSelfKeys: { [p: string]: boolean } = {},\n    private readonly recoveredParentKeys: { [parentId: string]: KeyPair<string> } = {}\n  ) {\n    this.keyPair = keyPair\n    this.verifiedSelfKeys = verifiedSelfKeys\n  }\n\n  async generateNewKeyForDataOwner(self: DataOwnerWithType): Promise<KeyPair<CryptoKey> | boolean> {\n    if (!this.keyPair) return false\n    const knownKeys = hexPublicKeysOf(self.dataOwner)\n    const publicKey = ua2hex(await this.RSA.exportKey(this.keyPair.publicKey, 'spki'))\n    return knownKeys.has(publicKey) ? false : this.keyPair\n  }\n\n  async recoverAndVerifySelfHierarchyKeys(\n    keysData: { dataOwner: DataOwnerWithType; unknownKeys: string[]; unavailableKeys: string[] }[],\n    cryptoPrimitives: CryptoPrimitives\n  ): Promise<{ [p: string]: { recoveredKeys: { [p: string]: KeyPair<CryptoKey> }; keyAuthenticity: { [p: string]: boolean } } }> {\n    this.recoverAndVerifyCallsParams.push(keysData)\n    const self = keysData[keysData.length - 1].dataOwner\n    const knownKeys = hexPublicKeysOf(self.dataOwner)\n    const publicKey = this.keyPair ? ua2hex(await this.RSA.exportKey(this.keyPair.publicKey, 'spki')) : undefined\n    return Object.fromEntries(\n      await Promise.all(\n        keysData.map(async (currData) => {\n          if (currData.dataOwner.dataOwner.id! !== self.dataOwner.id!) {\n            const recoveredKey = this.recoveredParentKeys[currData.dataOwner.dataOwner.id!]\n            return [\n              currData.dataOwner.dataOwner.id!,\n              {\n                recoveredKeys: recoveredKey\n                  ? {\n                      [recoveredKey.publicKey.slice(-32)]: await cryptoPrimitives.RSA.importKeyPair(\n                        'pkcs8',\n                        hex2ua(recoveredKey.privateKey),\n                        'spki',\n                        hex2ua(recoveredKey.publicKey)\n                      ),\n                    }\n                  : {},\n                keyAuthenticity: {},\n              },\n            ]\n          } else if (publicKey === undefined || !knownKeys.has(publicKey)) {\n            return [currData.dataOwner.dataOwner.id!, { recoveredKeys: {}, keyAuthenticity: this.verifiedSelfKeys }]\n          } else {\n            return [\n              currData.dataOwner.dataOwner.id!,\n              { recoveredKeys: { [publicKey.slice(-32)]: this.keyPair }, keyAuthenticity: this.verifiedSelfKeys },\n            ]\n          }\n        })\n      )\n    )\n  }\n\n  verifyDelegatePublicKeys(delegate: CryptoActorStubWithType, publicKeys: string[]): Promise<string[]> {\n    return Promise.resolve(publicKeys)\n  }\n}\n"]}

package/test/utils/TestStorage.d.ts

@@ -0,0 +1,31 @@
+import { KeyStorageFacade, StorageFacade } from '../../icc-x-api';
+import { KeyPair } from '../../icc-x-api/crypto/RSA';
+import { StorageEntryKeysFactory } from '../../icc-x-api/storage/StorageEntryKeysFactory';
+export declare class TestStorage implements StorageFacade<string> {
+    private readonly data;
+    getItem(key: string): Promise<string | undefined>;
+    removeItem(key: string): Promise<void>;
+    setItem(key: string, valueToStore: string): Promise<void>;
+}
+export declare class TestKeyStorage implements KeyStorageFacade {
+    private readonly data;
+    deleteKeypair(key: string): Promise<void>;
+    getKeypair(key: string): Promise<{
+        publicKey: JsonWebKey;
+        privateKey: JsonWebKey;
+    } | undefined>;
+    getPrivateKey(key: string): Promise<JsonWebKey | undefined>;
+    getPublicKey(key: string): Promise<JsonWebKey | undefined>;
+    storeKeyPair(key: string, keyPair: {
+        publicKey: JsonWebKey;
+        privateKey: JsonWebKey;
+    }): Promise<void>;
+}
+export declare function testStorageWithKeys(data: {
+    dataOwnerId: string;
+    pairs: KeyPair<string>[];
+}[]): Promise<{
+    keyStorage: KeyStorageFacade;
+    storage: StorageFacade<string>;
+    keyFactory: StorageEntryKeysFactory;
+}>;

package/test/utils/TestStorage.js

@@ -0,0 +1,88 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testStorageWithKeys = exports.TestKeyStorage = exports.TestStorage = void 0;
+const icc_x_api_1 = require("../../icc-x-api");
+const DefaultStorageEntryKeysFactory_1 = require("../../icc-x-api/storage/DefaultStorageEntryKeysFactory");
+const IcureStorageFacade_1 = require("../../icc-x-api/storage/IcureStorageFacade");
+class TestStorage {
+    constructor() {
+        this.data = new Map();
+    }
+    getItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.data.get(key);
+        });
+    }
+    removeItem(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.data.delete(key);
+        });
+    }
+    setItem(key, valueToStore) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.data.set(key, valueToStore);
+        });
+    }
+}
+exports.TestStorage = TestStorage;
+class TestKeyStorage {
+    constructor() {
+        this.data = new Map();
+    }
+    deleteKeypair(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.data.delete(key);
+        });
+    }
+    getKeypair(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.data.get(key);
+        });
+    }
+    getPrivateKey(key) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = (yield this.getKeypair(key))) === null || _a === void 0 ? void 0 : _a.privateKey;
+        });
+    }
+    getPublicKey(key) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_a = (yield this.getKeypair(key))) === null || _a === void 0 ? void 0 : _a.publicKey;
+        });
+    }
+    storeKeyPair(key, keyPair) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.data.set(key, keyPair);
+        });
+    }
+}
+exports.TestKeyStorage = TestKeyStorage;
+function testStorageWithKeys(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const keyStorage = new TestKeyStorage();
+        const keyFactory = new DefaultStorageEntryKeysFactory_1.DefaultStorageEntryKeysFactory();
+        const storage = new TestStorage();
+        const icureStorage = new IcureStorageFacade_1.IcureStorageFacade(keyStorage, storage, keyFactory);
+        for (const { dataOwnerId, pairs } of data) {
+            for (const pair of pairs) {
+                yield icureStorage.saveKey(dataOwnerId, pair.publicKey.slice(-32), {
+                    privateKey: (0, icc_x_api_1.pkcs8ToJwk)((0, icc_x_api_1.hex2ua)(pair.privateKey)),
+                    publicKey: (0, icc_x_api_1.spkiToJwk)((0, icc_x_api_1.hex2ua)(pair.publicKey)),
+                }, true);
+            }
+        }
+        return { keyFactory, keyStorage, storage };
+    });
+}
+exports.testStorageWithKeys = testStorageWithKeys;
+//# sourceMappingURL=TestStorage.js.map

package/test/utils/TestStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestStorage.js","sourceRoot":"","sources":["../../../test/utils/TestStorage.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAgG;AAGhG,2GAAuG;AACvG,mFAA+E;AAE/E,MAAa,WAAW;IAAxB;QACmB,SAAI,GAAG,IAAI,GAAG,EAAkB,CAAA;IAanD,CAAC;IAXO,OAAO,CAAC,GAAW;;YACvB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAC3B,CAAC;KAAA;IAEK,UAAU,CAAC,GAAW;;YAC1B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACvB,CAAC;KAAA;IAEK,OAAO,CAAC,GAAW,EAAE,YAAoB;;YAC7C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAA;QAClC,CAAC;KAAA;CACF;AAdD,kCAcC;AAED,MAAa,cAAc;IAA3B;QACmB,SAAI,GAAG,IAAI,GAAG,EAA+B,CAAA;IAqBhE,CAAC;IAnBO,aAAa,CAAC,GAAW;;YAC7B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACvB,CAAC;KAAA;IAEK,UAAU,CAAC,GAAW;;YAC1B,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QAC3B,CAAC;KAAA;IAEK,aAAa,CAAC,GAAW;;;YAC7B,OAAO,MAAA,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,0CAAE,UAAU,CAAA;;KAChD;IAEK,YAAY,CAAC,GAAW;;;YAC5B,OAAO,MAAA,CAAC,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,0CAAE,SAAS,CAAA;;KAC/C;IAEK,YAAY,CAAC,GAAW,EAAE,OAA0D;;YACxF,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;QAC7B,CAAC;KAAA;CACF;AAtBD,wCAsBC;AAED,SAAsB,mBAAmB,CACvC,IAAyD;;QAEzD,MAAM,UAAU,GAAG,IAAI,cAAc,EAAE,CAAA;QACvC,MAAM,UAAU,GAAG,IAAI,+DAA8B,EAAE,CAAA;QACvD,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAA;QACjC,MAAM,YAAY,GAAG,IAAI,uCAAkB,CAAC,UAAU,EAAE,OAAO,EAAE,UAAU,CAAC,CAAA;QAC5E,KAAK,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,IAAI,IAAI,EAAE;YACzC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;gBACxB,MAAM,YAAY,CAAC,OAAO,CACxB,WAAW,EACX,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,EACzB;oBACE,UAAU,EAAE,IAAA,sBAAU,EAAC,IAAA,kBAAM,EAAC,IAAI,CAAC,UAAU,CAAC,CAAC;oBAC/C,SAAS,EAAE,IAAA,qBAAS,EAAC,IAAA,kBAAM,EAAC,IAAI,CAAC,SAAS,CAAC,CAAC;iBAC7C,EACD,IAAI,CACL,CAAA;aACF;SACF;QACD,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,CAAA;IAC5C,CAAC;CAAA;AArBD,kDAqBC","sourcesContent":["import { hex2ua, KeyStorageFacade, pkcs8ToJwk, spkiToJwk, StorageFacade } from '../../icc-x-api'\nimport { KeyPair } from '../../icc-x-api/crypto/RSA'\nimport { StorageEntryKeysFactory } from '../../icc-x-api/storage/StorageEntryKeysFactory'\nimport { DefaultStorageEntryKeysFactory } from '../../icc-x-api/storage/DefaultStorageEntryKeysFactory'\nimport { IcureStorageFacade } from '../../icc-x-api/storage/IcureStorageFacade'\n\nexport class TestStorage implements StorageFacade<string> {\n  private readonly data = new Map<string, string>()\n\n  async getItem(key: string): Promise<string | undefined> {\n    return this.data.get(key)\n  }\n\n  async removeItem(key: string): Promise<void> {\n    this.data.delete(key)\n  }\n\n  async setItem(key: string, valueToStore: string): Promise<void> {\n    this.data.set(key, valueToStore)\n  }\n}\n\nexport class TestKeyStorage implements KeyStorageFacade {\n  private readonly data = new Map<string, KeyPair<JsonWebKey>>()\n\n  async deleteKeypair(key: string): Promise<void> {\n    this.data.delete(key)\n  }\n\n  async getKeypair(key: string): Promise<{ publicKey: JsonWebKey; privateKey: JsonWebKey } | undefined> {\n    return this.data.get(key)\n  }\n\n  async getPrivateKey(key: string): Promise<JsonWebKey | undefined> {\n    return (await this.getKeypair(key))?.privateKey\n  }\n\n  async getPublicKey(key: string): Promise<JsonWebKey | undefined> {\n    return (await this.getKeypair(key))?.publicKey\n  }\n\n  async storeKeyPair(key: string, keyPair: { publicKey: JsonWebKey; privateKey: JsonWebKey }): Promise<void> {\n    this.data.set(key, keyPair)\n  }\n}\n\nexport async function testStorageWithKeys(\n  data: { dataOwnerId: string; pairs: KeyPair<string>[] }[]\n): Promise<{ keyStorage: KeyStorageFacade; storage: StorageFacade<string>; keyFactory: StorageEntryKeysFactory }> {\n  const keyStorage = new TestKeyStorage()\n  const keyFactory = new DefaultStorageEntryKeysFactory()\n  const storage = new TestStorage()\n  const icureStorage = new IcureStorageFacade(keyStorage, storage, keyFactory)\n  for (const { dataOwnerId, pairs } of data) {\n    for (const pair of pairs) {\n      await icureStorage.saveKey(\n        dataOwnerId,\n        pair.publicKey.slice(-32),\n        {\n          privateKey: pkcs8ToJwk(hex2ua(pair.privateKey)),\n          publicKey: spkiToJwk(hex2ua(pair.publicKey)),\n        },\n        true\n      )\n    }\n  }\n  return { keyFactory, keyStorage, storage }\n}\n"]}

package/test/utils/test_utils.d.ts

@@ -0,0 +1,60 @@
+import { IcureApi, Apis } from '../../icc-x-api';
+import { User } from '../../icc-api/model/User';
+import { TestVars, UserDetails } from '@icure/test-setup/types';
+import { EnvInitializer } from '@icure/test-setup/decorators';
+import 'isomorphic-fetch';
+import { Group } from '../../icc-api/model/Group';
+export declare function getTempEmail(): string;
+export declare function setLocalStorage(fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>): void;
+export declare const hcp1Username: string;
+export declare const hcp2Username: string;
+export declare const hcp3Username: string;
+export declare const patUsername: string;
+export declare function getEnvironmentInitializer(): Promise<EnvInitializer>;
+export declare namespace TestUtils {
+    function initApi(envVars: TestVars, userName?: string): Promise<IcureApi>;
+    function initMasterApi(envVars: TestVars): Promise<IcureApi>;
+}
+export declare function getApiAndAddPrivateKeysForUser(iCureUrl: string, details: UserDetails): Promise<IcureApi>;
+export declare function createNewHcpApi(env: TestVars): Promise<{
+    api: Apis;
+    credentials: UserDetails;
+    user: User;
+}>;
+export declare function createHcpHierarchyApis(env: TestVars): Promise<{
+    grandApi: Apis;
+    grandUser: User;
+    grandCredentials: UserDetails;
+    parentApi: Apis;
+    parentUser: User;
+    parentCredentials: UserDetails;
+    childApi: Apis;
+    childUser: User;
+    childCredentials: UserDetails;
+    child2Api: Apis;
+    child2User: User;
+    child2Credentials: UserDetails;
+}>;
+/**
+ * Create a parent HCP with a key and a child HCP without any initialised key
+ */
+export declare function createNewHcpWithoutKeyAndParentWithKey(env: TestVars, props?: {
+    initialiseEmptyKeyForChild?: boolean;
+}): Promise<{
+    parentCredentials: UserDetails;
+    childUser: string;
+    childDataOwnerId: string;
+    childPassword: string;
+}>;
+export type UserInManyGroupsDetails = {
+    user1: User;
+    user2: User;
+    group3: Group;
+    userPw3: string;
+    user3: User;
+    group2: Group;
+    group1: Group;
+    userPw12: string;
+    userLogin: string;
+};
+export declare function createUserInMultipleGroups(env: TestVars): Promise<UserInManyGroupsDetails>;

package/test/utils/test_utils.js

@@ -0,0 +1,313 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUserInMultipleGroups = exports.createNewHcpWithoutKeyAndParentWithKey = exports.createHcpHierarchyApis = exports.createNewHcpApi = exports.getApiAndAddPrivateKeysForUser = exports.TestUtils = exports.getEnvironmentInitializer = exports.patUsername = exports.hcp3Username = exports.hcp2Username = exports.hcp1Username = exports.setLocalStorage = exports.getTempEmail = void 0;
+const icc_x_api_1 = require("../../icc-x-api");
+const os_1 = require("os");
+const util_1 = require("util");
+const uuid_1 = require("uuid");
+const crypto_1 = require("crypto");
+const TestApi_1 = require("./TestApi");
+const apiV6_1 = require("@icure/apiV6");
+const TestStorage_1 = require("./TestStorage");
+const TestCryptoStrategies_1 = require("./TestCryptoStrategies");
+const User_1 = require("../../icc-api/model/User");
+const builder_1 = require("@icure/test-setup/builder");
+const types_1 = require("@icure/test-setup/types");
+require("isomorphic-fetch");
+const icc_api_1 = require("../../icc-api");
+function getTempEmail() {
+    return `${(0, uuid_1.v4)().substring(0, 8)}@icure.com`;
+}
+exports.getTempEmail = getTempEmail;
+function setLocalStorage(fetch) {
+    ;
+    global.localStorage = new (require('node-localstorage').LocalStorage)((0, os_1.tmpdir)(), 5 * Math.pow(1024, 3));
+    global.fetch = fetch;
+    global.Storage = '';
+    global.TextDecoder = util_1.TextDecoder;
+    global.TextEncoder = util_1.TextEncoder;
+    global.headers = Headers;
+}
+exports.setLocalStorage = setLocalStorage;
+exports.hcp1Username = (_a = process.env.ICURE_TS_TEST_HCP_USER) !== null && _a !== void 0 ? _a : getTempEmail();
+exports.hcp2Username = (_b = process.env.ICURE_TS_TEST_HCP_2_USER) !== null && _b !== void 0 ? _b : getTempEmail();
+exports.hcp3Username = (_c = process.env.ICURE_TS_TEST_HCP_3_USER) !== null && _c !== void 0 ? _c : getTempEmail();
+exports.patUsername = (_d = process.env.ICURE_TS_TEST_PAT_USER) !== null && _d !== void 0 ? _d : getTempEmail();
+let cachedInitializer;
+function getEnvironmentInitializer() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!cachedInitializer) {
+            const env = (0, types_1.getEnvVariables)();
+            const scratchDir = 'test/scratch';
+            const baseEnvironment = env.testEnvironment === 'docker' ? new builder_1.TestEnvironmentBuilder().setUpDockerEnvironment(scratchDir, ['mock']) : new builder_1.TestEnvironmentBuilder();
+            cachedInitializer = yield baseEnvironment
+                .withGroup(fetch, {
+                patient: ['BASIC_USER', 'BASIC_DATA_OWNER'],
+                hcp: [
+                    'BASIC_USER',
+                    'BASIC_DATA_OWNER',
+                    'PATIENT_USER_MANAGER',
+                    'HIERARCHICAL_DATA_OWNER',
+                    'TOPIC_MANAGER',
+                    'TOPIC_PARTICIPANT',
+                    'LEGACY_MESSAGE_MANAGER',
+                ],
+                device: ['BASIC_USER', 'BASIC_DATA_OWNER'],
+                user: ['BASIC_USER'],
+            })
+                .withMasterUser(fetch)
+                .addHcp({ login: exports.hcp1Username })
+                .addHcp({ login: exports.hcp2Username })
+                .addHcp({ login: exports.hcp3Username })
+                .addPatient({ login: exports.patUsername })
+                .withSafeguard()
+                .withEnvironmentSummary()
+                .build();
+        }
+        return cachedInitializer;
+    });
+}
+exports.getEnvironmentInitializer = getEnvironmentInitializer;
+var TestUtils;
+(function (TestUtils) {
+    function initApi(envVars, userName = exports.hcp1Username) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield getApiAndAddPrivateKeysForUser(envVars.iCureUrl, envVars.dataOwnerDetails[userName]);
+        });
+    }
+    TestUtils.initApi = initApi;
+    function initMasterApi(envVars) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield getApiAndAddPrivateKeysForUser(envVars.iCureUrl, envVars.masterHcp);
+        });
+    }
+    TestUtils.initMasterApi = initMasterApi;
+})(TestUtils = exports.TestUtils || (exports.TestUtils = {}));
+function getApiAndAddPrivateKeysForUser(iCureUrl, details) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const RSA = new icc_x_api_1.RSAUtils(crypto_1.webcrypto);
+        const keys = {
+            publicKey: yield RSA.importKey('spki', (0, icc_x_api_1.hex2ua)(details.publicKey), ['encrypt']),
+            privateKey: yield RSA.importKey('pkcs8', (0, icc_x_api_1.hex2ua)(details.privateKey), ['decrypt']),
+        };
+        return yield (0, TestApi_1.TestApi)(iCureUrl, details.user, details.password, crypto_1.webcrypto, keys);
+    });
+}
+exports.getApiAndAddPrivateKeysForUser = getApiAndAddPrivateKeysForUser;
+function createHealthcarePartyUser(api, userLogin, userToken, publicKey, privateKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { publicKey: newPublicKey, privateKey: newPrivateKey } = yield api.cryptoApi.RSA.generateKeyPair();
+        const publicKeyHex = !!publicKey && !!privateKey ? publicKey : (0, icc_x_api_1.ua2hex)(yield api.cryptoApi.RSA.exportKey(newPublicKey, 'spki'));
+        const privateKeyHex = !!publicKey && !!privateKey ? privateKey : (0, icc_x_api_1.ua2hex)(yield api.cryptoApi.RSA.exportKey(newPrivateKey, 'pkcs8'));
+        const hcp = yield api.healthcarePartyApi.createHealthcareParty(new apiV6_1.HealthcareParty({
+            id: (0, uuid_1.v4)(),
+            firstName: (0, uuid_1.v4)().substring(0, 6),
+            lastName: (0, uuid_1.v4)().substring(0, 6),
+            publicKey: publicKeyHex,
+        }));
+        const hcpUser = yield api.userApi.createUser(new User_1.User({
+            id: (0, uuid_1.v4)(),
+            name: userLogin,
+            login: userLogin,
+            email: userLogin,
+            healthcarePartyId: hcp.id,
+        }));
+        const token = yield api.userApi.getToken(hcpUser.id, (0, uuid_1.v4)(), 24 * 60 * 60, userToken);
+        return {
+            user: hcpUser.login,
+            dataOwnerId: hcp.id,
+            password: token,
+            publicKey: publicKeyHex,
+            privateKey: privateKeyHex,
+        };
+    });
+}
+function createNewHcpApi(env) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const initialisationApi = yield (0, apiV6_1.Api)(env.iCureUrl + '/rest/v1', env.masterHcp.user, env.masterHcp.password, crypto_1.webcrypto, fetch, true, false);
+        const primitives = new icc_x_api_1.CryptoPrimitives(crypto_1.webcrypto);
+        const credentials = yield createHealthcarePartyUser(initialisationApi, `user-${primitives.randomUuid()}`, primitives.randomUuid());
+        const storage = yield (0, TestStorage_1.testStorageWithKeys)([
+            { dataOwnerId: credentials.dataOwnerId, pairs: [{ privateKey: credentials.privateKey, publicKey: credentials.publicKey }] },
+        ]);
+        const api = yield icc_x_api_1.IcureApi.initialise(env.iCureUrl, { username: credentials.user, password: credentials.password }, new TestCryptoStrategies_1.TestCryptoStrategies(), crypto_1.webcrypto, fetch, {
+            storage: storage.storage,
+            keyStorage: storage.keyStorage,
+            entryKeysFactory: storage.keyFactory,
+        });
+        return { api, credentials, user: yield api.userApi.getCurrentUser() };
+    });
+}
+exports.createNewHcpApi = createNewHcpApi;
+function createHcpHierarchyApis(env) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const initialisationApi = yield (0, apiV6_1.Api)(env.iCureUrl + '/rest/v1', env.masterHcp.user, env.masterHcp.password, crypto_1.webcrypto, fetch, true, false);
+        const primitives = new icc_x_api_1.CryptoPrimitives(crypto_1.webcrypto);
+        const grandCredentials = yield createHealthcarePartyUser(initialisationApi, `grand-${primitives.randomUuid()}`, primitives.randomUuid());
+        const parentCredentials = yield createHealthcarePartyUser(initialisationApi, `parent-${primitives.randomUuid()}`, primitives.randomUuid());
+        const childCredentials = yield createHealthcarePartyUser(initialisationApi, `child-${primitives.randomUuid()}`, primitives.randomUuid());
+        const child2Credentials = yield createHealthcarePartyUser(initialisationApi, `child2-${primitives.randomUuid()}`, primitives.randomUuid());
+        yield initialisationApi.healthcarePartyApi.modifyHealthcareParty(Object.assign(Object.assign({}, (yield initialisationApi.healthcarePartyApi.getHealthcareParty(parentCredentials.dataOwnerId))), { parentId: grandCredentials.dataOwnerId }));
+        yield initialisationApi.healthcarePartyApi.modifyHealthcareParty(Object.assign(Object.assign({}, (yield initialisationApi.healthcarePartyApi.getHealthcareParty(childCredentials.dataOwnerId))), { parentId: parentCredentials.dataOwnerId }));
+        yield initialisationApi.healthcarePartyApi.modifyHealthcareParty(Object.assign(Object.assign({}, (yield initialisationApi.healthcarePartyApi.getHealthcareParty(child2Credentials.dataOwnerId))), { parentId: grandCredentials.dataOwnerId }));
+        const grandStorage = yield (0, TestStorage_1.testStorageWithKeys)([
+            { dataOwnerId: grandCredentials.dataOwnerId, pairs: [{ privateKey: grandCredentials.privateKey, publicKey: grandCredentials.publicKey }] },
+        ]);
+        const grandApi = yield icc_x_api_1.IcureApi.initialise(env.iCureUrl, { username: grandCredentials.user, password: grandCredentials.password }, new TestCryptoStrategies_1.TestCryptoStrategies(), crypto_1.webcrypto, fetch, {
+            storage: grandStorage.storage,
+            keyStorage: grandStorage.keyStorage,
+            entryKeysFactory: grandStorage.keyFactory,
+        });
+        const parentStorage = yield (0, TestStorage_1.testStorageWithKeys)([
+            { dataOwnerId: grandCredentials.dataOwnerId, pairs: [{ privateKey: grandCredentials.privateKey, publicKey: grandCredentials.publicKey }] },
+            { dataOwnerId: parentCredentials.dataOwnerId, pairs: [{ privateKey: parentCredentials.privateKey, publicKey: parentCredentials.publicKey }] },
+        ]);
+        const parentApi = yield icc_x_api_1.IcureApi.initialise(env.iCureUrl, { username: parentCredentials.user, password: parentCredentials.password }, new TestCryptoStrategies_1.TestCryptoStrategies(), crypto_1.webcrypto, fetch, {
+            storage: parentStorage.storage,
+            keyStorage: parentStorage.keyStorage,
+            entryKeysFactory: parentStorage.keyFactory,
+        });
+        const parentUser = yield parentApi.userApi.modifyUser(Object.assign(Object.assign({}, (yield parentApi.userApi.getCurrentUser())), { autoDelegations: { all: [grandCredentials.dataOwnerId] } }));
+        const childStorage = yield (0, TestStorage_1.testStorageWithKeys)([
+            { dataOwnerId: grandCredentials.dataOwnerId, pairs: [{ privateKey: grandCredentials.privateKey, publicKey: grandCredentials.publicKey }] },
+            { dataOwnerId: parentCredentials.dataOwnerId, pairs: [{ privateKey: parentCredentials.privateKey, publicKey: parentCredentials.publicKey }] },
+            { dataOwnerId: childCredentials.dataOwnerId, pairs: [{ privateKey: childCredentials.privateKey, publicKey: childCredentials.publicKey }] },
+        ]);
+        const childApi = yield icc_x_api_1.IcureApi.initialise(env.iCureUrl, { username: childCredentials.user, password: childCredentials.password }, new TestCryptoStrategies_1.TestCryptoStrategies(), crypto_1.webcrypto, fetch, {
+            storage: childStorage.storage,
+            keyStorage: childStorage.keyStorage,
+            entryKeysFactory: childStorage.keyFactory,
+        });
+        const childUser = yield childApi.userApi.modifyUser(Object.assign(Object.assign({}, (yield childApi.userApi.getCurrentUser())), { autoDelegations: { all: [grandCredentials.dataOwnerId, parentCredentials.dataOwnerId] } }));
+        const child2Storage = yield (0, TestStorage_1.testStorageWithKeys)([
+            { dataOwnerId: grandCredentials.dataOwnerId, pairs: [{ privateKey: grandCredentials.privateKey, publicKey: grandCredentials.publicKey }] },
+            { dataOwnerId: child2Credentials.dataOwnerId, pairs: [{ privateKey: child2Credentials.privateKey, publicKey: child2Credentials.publicKey }] },
+        ]);
+        const child2Api = yield icc_x_api_1.IcureApi.initialise(env.iCureUrl, { username: child2Credentials.user, password: child2Credentials.password }, new TestCryptoStrategies_1.TestCryptoStrategies(), crypto_1.webcrypto, fetch, {
+            storage: child2Storage.storage,
+            keyStorage: child2Storage.keyStorage,
+            entryKeysFactory: child2Storage.keyFactory,
+        });
+        const child2User = yield child2Api.userApi.modifyUser(Object.assign(Object.assign({}, (yield child2Api.userApi.getCurrentUser())), { autoDelegations: { all: [grandCredentials.dataOwnerId] } }));
+        return {
+            grandApi,
+            grandUser: yield grandApi.userApi.getCurrentUser(),
+            grandCredentials,
+            parentApi,
+            parentUser,
+            parentCredentials,
+            childApi,
+            childUser,
+            childCredentials,
+            child2Api,
+            child2User,
+            child2Credentials,
+        };
+    });
+}
+exports.createHcpHierarchyApis = createHcpHierarchyApis;
+/**
+ * Create a parent HCP with a key and a child HCP without any initialised key
+ */
+function createNewHcpWithoutKeyAndParentWithKey(env, props = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const initialisationApi = yield (0, apiV6_1.Api)(env.iCureUrl + '/rest/v1', env.masterHcp.user, env.masterHcp.password, crypto_1.webcrypto, fetch, true, false);
+        const primitives = new icc_x_api_1.CryptoPrimitives(crypto_1.webcrypto);
+        const parentCredentials = yield createHealthcarePartyUser(initialisationApi, `parent-${primitives.randomUuid()}`, primitives.randomUuid());
+        const childUser = (0, uuid_1.v4)() + '@email.com';
+        const childPassword = (0, uuid_1.v4)();
+        const childHcp = new apiV6_1.HealthcareParty({
+            id: (0, uuid_1.v4)(),
+            firstName: (0, uuid_1.v4)().substring(0, 6),
+            lastName: (0, uuid_1.v4)().substring(0, 6),
+            parentId: parentCredentials.dataOwnerId,
+        });
+        if (props.initialiseEmptyKeyForChild) {
+            childHcp.publicKey = '';
+        }
+        yield initialisationApi.healthcarePartyApi.createHealthcareParty(childHcp);
+        yield initialisationApi.userApi.createUser(new User_1.User({
+            id: (0, uuid_1.v4)(),
+            name: childUser,
+            login: childUser,
+            email: childUser,
+            passwordHash: childPassword,
+            healthcarePartyId: childHcp.id,
+        }));
+        return {
+            parentCredentials,
+            childUser,
+            childPassword,
+            childDataOwnerId: childHcp.id,
+        };
+    });
+}
+exports.createNewHcpWithoutKeyAndParentWithKey = createNewHcpWithoutKeyAndParentWithKey;
+function createUserInMultipleGroups(env) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const primitives = new icc_x_api_1.CryptoPrimitives(crypto_1.webcrypto);
+        const userGroup1Id = primitives.randomUuid(); // Same username-pw as group 2
+        const userGroup2Id = primitives.randomUuid(); // Same username-pw as group 1
+        const userGroup3Id = primitives.randomUuid(); // Same username as group 1/2, different pw
+        const userLogin = `maria-${primitives.randomUuid()}@pompei.it`;
+        const userPw12 = `geppetto-${primitives.randomUuid()}`;
+        const userPw3 = `pinocchio-${primitives.randomUuid()}`;
+        const user1Id = primitives.randomUuid();
+        const user2Id = primitives.randomUuid();
+        const user3Id = primitives.randomUuid();
+        const api = yield icc_x_api_1.IcureBasicApi.initialise(env.iCureUrl, { username: 'john', password: 'LetMeIn' }, fetch); // pragma: allowlist secret
+        const group1 = yield api.groupApi.createGroup(userGroup1Id, `test-group-1-${primitives.randomUuid()}`, primitives.randomUuid(), undefined, undefined, undefined, undefined, undefined, {});
+        const group2 = yield api.groupApi.createGroup(userGroup2Id, `test-group-2-${primitives.randomUuid()}`, primitives.randomUuid(), undefined, undefined, undefined, undefined, undefined, {});
+        const group3 = yield api.groupApi.createGroup(userGroup3Id, `test-group-3-${primitives.randomUuid()}`, primitives.randomUuid(), undefined, undefined, undefined, undefined, undefined, {});
+        const user1 = yield api.userApi.createUserInGroup(userGroup1Id, {
+            id: user1Id,
+            name: userLogin,
+            login: userLogin,
+            email: userLogin,
+            passwordHash: userPw12,
+        });
+        const user2 = yield api.userApi.createUserInGroup(userGroup2Id, {
+            id: user2Id,
+            name: userLogin,
+            login: userLogin,
+            email: userLogin,
+            passwordHash: userPw12,
+        });
+        const user3 = yield api.userApi.createUserInGroup(userGroup3Id, {
+            id: user3Id,
+            name: userLogin,
+            login: userLogin,
+            email: userLogin,
+            passwordHash: userPw3,
+        });
+        console.log(`Waiting for user to be created - ${userLogin}`);
+        yield (0, icc_x_api_1.retry)(() => __awaiter(this, void 0, void 0, function* () {
+            yield new icc_api_1.IccUserApi(env.iCureUrl, {}, new icc_x_api_1.BasicAuthenticationProvider(`${userGroup1Id}/${user1Id}`, userPw12), fetch).getCurrentUser();
+            yield new icc_api_1.IccUserApi(env.iCureUrl, {}, new icc_x_api_1.BasicAuthenticationProvider(`${userGroup2Id}/${user2Id}`, userPw12), fetch).getCurrentUser();
+            yield new icc_api_1.IccUserApi(env.iCureUrl, {}, new icc_x_api_1.BasicAuthenticationProvider(`${userGroup3Id}/${user3Id}`, userPw3), fetch).getCurrentUser();
+        }), 10, 5000, 1);
+        return {
+            user1,
+            user2,
+            group3,
+            userPw3,
+            user3,
+            group2,
+            group1,
+            userPw12,
+            userLogin,
+        };
+    });
+}
+exports.createUserInMultipleGroups = createUserInMultipleGroups;
+//# sourceMappingURL=test_utils.js.map