@icure/api 7.1.4 → 7.1.6

package/test/utils/TestStorage.ts

@@ -0,0 +1,68 @@
+import { hex2ua, KeyStorageFacade, pkcs8ToJwk, spkiToJwk, StorageFacade } from '../../icc-x-api'
+import { KeyPair } from '../../icc-x-api/crypto/RSA'
+import { StorageEntryKeysFactory } from '../../icc-x-api/storage/StorageEntryKeysFactory'
+import { DefaultStorageEntryKeysFactory } from '../../icc-x-api/storage/DefaultStorageEntryKeysFactory'
+import { IcureStorageFacade } from '../../icc-x-api/storage/IcureStorageFacade'
+
+export class TestStorage implements StorageFacade<string> {
+  private readonly data = new Map<string, string>()
+
+  async getItem(key: string): Promise<string | undefined> {
+    return this.data.get(key)
+  }
+
+  async removeItem(key: string): Promise<void> {
+    this.data.delete(key)
+  }
+
+  async setItem(key: string, valueToStore: string): Promise<void> {
+    this.data.set(key, valueToStore)
+  }
+}
+
+export class TestKeyStorage implements KeyStorageFacade {
+  private readonly data = new Map<string, KeyPair<JsonWebKey>>()
+
+  async deleteKeypair(key: string): Promise<void> {
+    this.data.delete(key)
+  }
+
+  async getKeypair(key: string): Promise<{ publicKey: JsonWebKey; privateKey: JsonWebKey } | undefined> {
+    return this.data.get(key)
+  }
+
+  async getPrivateKey(key: string): Promise<JsonWebKey | undefined> {
+    return (await this.getKeypair(key))?.privateKey
+  }
+
+  async getPublicKey(key: string): Promise<JsonWebKey | undefined> {
+    return (await this.getKeypair(key))?.publicKey
+  }
+
+  async storeKeyPair(key: string, keyPair: { publicKey: JsonWebKey; privateKey: JsonWebKey }): Promise<void> {
+    this.data.set(key, keyPair)
+  }
+}
+
+export async function testStorageWithKeys(
+  data: { dataOwnerId: string; pairs: KeyPair<string>[] }[]
+): Promise<{ keyStorage: KeyStorageFacade; storage: StorageFacade<string>; keyFactory: StorageEntryKeysFactory }> {
+  const keyStorage = new TestKeyStorage()
+  const keyFactory = new DefaultStorageEntryKeysFactory()
+  const storage = new TestStorage()
+  const icureStorage = new IcureStorageFacade(keyStorage, storage, keyFactory)
+  for (const { dataOwnerId, pairs } of data) {
+    for (const pair of pairs) {
+      await icureStorage.saveKey(
+        dataOwnerId,
+        pair.publicKey.slice(-32),
+        {
+          privateKey: pkcs8ToJwk(hex2ua(pair.privateKey)),
+          publicKey: spkiToJwk(hex2ua(pair.publicKey)),
+        },
+        true
+      )
+    }
+  }
+  return { keyFactory, keyStorage, storage }
+}

package/test/utils/test_utils.ts

@@ -0,0 +1,279 @@
+import { Apis, hex2ua, IcureApi, ua2hex } from '../../icc-x-api'
+import { tmpdir } from 'os'
+import { TextDecoder, TextEncoder } from 'util'
+import { v4 as uuid } from 'uuid'
+import { webcrypto } from 'crypto'
+import { RSAUtils } from '../../icc-x-api/crypto/RSA'
+import { TestApi } from './TestApi'
+import { Api as TestSetupApi, Apis as TestSetupApis, HealthcareParty } from '@icure/apiV6'
+import { CryptoPrimitives } from '../../icc-x-api/crypto/CryptoPrimitives'
+import { testStorageWithKeys } from './TestStorage'
+import { TestCryptoStrategies } from './TestCryptoStrategies'
+import { User } from '../../icc-api/model/User'
+import { TestEnvironmentBuilder } from '@icure/test-setup/builder'
+import { getEnvVariables, TestVars, UserDetails } from '@icure/test-setup/types'
+import { EnvInitializer } from '@icure/test-setup/decorators'
+
+export function getTempEmail(): string {
+  return `${uuid().substring(0, 8)}@icure.com`
+}
+
+export function setLocalStorage(fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>) {
+  ;(global as any).localStorage = new (require('node-localstorage').LocalStorage)(tmpdir(), 5 * 1024 ** 3)
+  ;(global as any).fetch = fetch
+  ;(global as any).Storage = ''
+  ;(global as any).TextDecoder = TextDecoder
+  ;(global as any).TextEncoder = TextEncoder
+  ;(global as any).headers = Headers
+}
+
+export const hcp1Username = process.env.ICURE_TS_TEST_HCP_USER ?? getTempEmail()
+export const hcp2Username = process.env.ICURE_TS_TEST_HCP_2_USER ?? getTempEmail()
+export const hcp3Username = process.env.ICURE_TS_TEST_HCP_3_USER ?? getTempEmail()
+export const patUsername = process.env.ICURE_TS_TEST_PAT_USER ?? getTempEmail()
+
+let cachedInitializer: EnvInitializer | undefined
+
+export async function getEnvironmentInitializer(): Promise<EnvInitializer> {
+  if (!cachedInitializer) {
+    const env = getEnvVariables()
+    const scratchDir = 'test/scratch'
+    const baseEnvironment =
+      env.testEnvironment === 'docker' ? new TestEnvironmentBuilder().setUpDockerEnvironment(scratchDir, ['mock']) : new TestEnvironmentBuilder()
+    cachedInitializer = await baseEnvironment
+      .withGroup(fetch)
+      .withMasterUser(fetch)
+      .addHcp({ login: hcp1Username })
+      .addHcp({ login: hcp2Username })
+      .addHcp({ login: hcp3Username })
+      .addPatient({ login: patUsername })
+      .withSafeguard()
+      .withEnvironmentSummary()
+      .build()
+  }
+  return cachedInitializer
+}
+
+export namespace TestUtils {
+  export async function initApi(envVars: TestVars, userName: string = hcp1Username): Promise<IcureApi> {
+    return await getApiAndAddPrivateKeysForUser(envVars.iCureUrl, envVars.dataOwnerDetails[userName])
+  }
+
+  export async function initMasterApi(envVars: TestVars): Promise<Apis> {
+    return await getApiAndAddPrivateKeysForUser(envVars.iCureUrl, envVars.masterHcp!)
+  }
+}
+
+export async function getApiAndAddPrivateKeysForUser(iCureUrl: string, details: UserDetails) {
+  const RSA = new RSAUtils(webcrypto as any)
+  const keys = {
+    publicKey: await RSA.importKey('spki', hex2ua(details.publicKey), ['encrypt']),
+    privateKey: await RSA.importKey('pkcs8', hex2ua(details.privateKey), ['decrypt']),
+  }
+  return await TestApi(iCureUrl, details.user, details.password, webcrypto as any, keys)
+}
+
+async function createHealthcarePartyUser(
+  api: TestSetupApis,
+  userLogin: string,
+  userToken: string,
+  publicKey?: string,
+  privateKey?: string
+): Promise<UserDetails> {
+  const { publicKey: newPublicKey, privateKey: newPrivateKey } = await api.cryptoApi.RSA.generateKeyPair()
+
+  const publicKeyHex = !!publicKey && !!privateKey ? publicKey : ua2hex(await api.cryptoApi.RSA.exportKey(newPublicKey, 'spki'))
+  const privateKeyHex = !!publicKey && !!privateKey ? privateKey : ua2hex(await api.cryptoApi.RSA.exportKey(newPrivateKey, 'pkcs8'))
+
+  const hcp = await api.healthcarePartyApi.createHealthcareParty(
+    new HealthcareParty({
+      id: uuid(),
+      firstName: uuid().substring(0, 6),
+      lastName: uuid().substring(0, 6),
+      publicKey: publicKeyHex,
+    })
+  )
+  const hcpUser = await api.userApi.createUser(
+    new User({
+      id: uuid(),
+      name: userLogin,
+      login: userLogin,
+      email: userLogin,
+      healthcarePartyId: hcp.id,
+    })
+  )
+  const token = await api.userApi.getToken(hcpUser.id!, uuid(), 24 * 60 * 60, userToken)
+  return {
+    user: hcpUser.login!,
+    dataOwnerId: hcp.id!,
+    password: token,
+    publicKey: publicKeyHex,
+    privateKey: privateKeyHex,
+  }
+}
+
+export async function createNewHcpApi(env: TestVars): Promise<{
+  api: Apis
+  credentials: UserDetails
+  user: User
+}> {
+  const initialisationApi = await TestSetupApi(
+    env.iCureUrl + '/rest/v1',
+    env.masterHcp!.user,
+    env.masterHcp!.password,
+    webcrypto as any,
+    fetch,
+    true,
+    false
+  )
+  const primitives = new CryptoPrimitives(webcrypto as any)
+  const credentials = await createHealthcarePartyUser(initialisationApi, `user-${primitives.randomUuid()}`, primitives.randomUuid())
+  const storage = await testStorageWithKeys([
+    { dataOwnerId: credentials.dataOwnerId, pairs: [{ privateKey: credentials.privateKey, publicKey: credentials.publicKey }] },
+  ])
+  const api = await IcureApi.initialise(
+    env.iCureUrl,
+    { username: credentials.user, password: credentials.password },
+    new TestCryptoStrategies(),
+    webcrypto as any,
+    fetch,
+    {
+      storage: storage.storage,
+      keyStorage: storage.keyStorage,
+      entryKeysFactory: storage.keyFactory,
+    }
+  )
+  return { api, credentials, user: await api.userApi.getCurrentUser() }
+}
+
+export async 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
+}> {
+  const initialisationApi = await TestSetupApi(
+    env.iCureUrl + '/rest/v1',
+    env.masterHcp!.user,
+    env.masterHcp!.password,
+    webcrypto as any,
+    fetch,
+    true,
+    false
+  )
+  const primitives = new CryptoPrimitives(webcrypto as any)
+  const grandCredentials = await createHealthcarePartyUser(initialisationApi, `grand-${primitives.randomUuid()}`, primitives.randomUuid())
+  const parentCredentials = await createHealthcarePartyUser(initialisationApi, `parent-${primitives.randomUuid()}`, primitives.randomUuid())
+  const childCredentials = await createHealthcarePartyUser(initialisationApi, `child-${primitives.randomUuid()}`, primitives.randomUuid())
+  const child2Credentials = await createHealthcarePartyUser(initialisationApi, `child2-${primitives.randomUuid()}`, primitives.randomUuid())
+  await initialisationApi.healthcarePartyApi.modifyHealthcareParty({
+    ...(await initialisationApi.healthcarePartyApi.getHealthcareParty(parentCredentials.dataOwnerId)),
+    parentId: grandCredentials.dataOwnerId,
+  })
+  await initialisationApi.healthcarePartyApi.modifyHealthcareParty({
+    ...(await initialisationApi.healthcarePartyApi.getHealthcareParty(childCredentials.dataOwnerId)),
+    parentId: parentCredentials.dataOwnerId,
+  })
+  await initialisationApi.healthcarePartyApi.modifyHealthcareParty({
+    ...(await initialisationApi.healthcarePartyApi.getHealthcareParty(child2Credentials.dataOwnerId)),
+    parentId: grandCredentials.dataOwnerId,
+  })
+  const grandStorage = await testStorageWithKeys([
+    { dataOwnerId: grandCredentials.dataOwnerId, pairs: [{ privateKey: grandCredentials.privateKey, publicKey: grandCredentials.publicKey }] },
+  ])
+  const grandApi = await IcureApi.initialise(
+    env.iCureUrl,
+    { username: grandCredentials.user, password: grandCredentials.password },
+    new TestCryptoStrategies(),
+    webcrypto as any,
+    fetch,
+    {
+      storage: grandStorage.storage,
+      keyStorage: grandStorage.keyStorage,
+      entryKeysFactory: grandStorage.keyFactory,
+    }
+  )
+  const parentStorage = await testStorageWithKeys([
+    { dataOwnerId: grandCredentials.dataOwnerId, pairs: [{ privateKey: grandCredentials.privateKey, publicKey: grandCredentials.publicKey }] },
+    { dataOwnerId: parentCredentials.dataOwnerId, pairs: [{ privateKey: parentCredentials.privateKey, publicKey: parentCredentials.publicKey }] },
+  ])
+  const parentApi = await IcureApi.initialise(
+    env.iCureUrl,
+    { username: parentCredentials.user, password: parentCredentials.password },
+    new TestCryptoStrategies(),
+    webcrypto as any,
+    fetch,
+    {
+      storage: parentStorage.storage,
+      keyStorage: parentStorage.keyStorage,
+      entryKeysFactory: parentStorage.keyFactory,
+    }
+  )
+  const parentUser = await parentApi.userApi.modifyUser({
+    ...(await parentApi.userApi.getCurrentUser()),
+    autoDelegations: { all: [grandCredentials.dataOwnerId] },
+  })
+  const childStorage = await 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 = await IcureApi.initialise(
+    env.iCureUrl,
+    { username: childCredentials.user, password: childCredentials.password },
+    new TestCryptoStrategies(),
+    webcrypto as any,
+    fetch,
+    {
+      storage: childStorage.storage,
+      keyStorage: childStorage.keyStorage,
+      entryKeysFactory: childStorage.keyFactory,
+    }
+  )
+  const childUser = await childApi.userApi.modifyUser({
+    ...(await childApi.userApi.getCurrentUser()),
+    autoDelegations: { all: [grandCredentials.dataOwnerId, parentCredentials.dataOwnerId] },
+  })
+  const child2Storage = await testStorageWithKeys([
+    { dataOwnerId: grandCredentials.dataOwnerId, pairs: [{ privateKey: grandCredentials.privateKey, publicKey: grandCredentials.publicKey }] },
+    { dataOwnerId: child2Credentials.dataOwnerId, pairs: [{ privateKey: child2Credentials.privateKey, publicKey: child2Credentials.publicKey }] },
+  ])
+  const child2Api = await IcureApi.initialise(
+    env.iCureUrl,
+    { username: child2Credentials.user, password: child2Credentials.password },
+    new TestCryptoStrategies(),
+    webcrypto as any,
+    fetch,
+    {
+      storage: child2Storage.storage,
+      keyStorage: child2Storage.keyStorage,
+      entryKeysFactory: child2Storage.keyFactory,
+    }
+  )
+  const child2User = await child2Api.userApi.modifyUser({
+    ...(await child2Api.userApi.getCurrentUser()),
+    autoDelegations: { all: [grandCredentials.dataOwnerId] },
+  })
+  return {
+    grandApi,
+    grandUser: await grandApi.userApi.getCurrentUser(),
+    grandCredentials,
+    parentApi,
+    parentUser,
+    parentCredentials,
+    childApi,
+    childUser,
+    childCredentials,
+    child2Api,
+    child2User,
+    child2Credentials,
+  }
+}

package/test-scripts/cleanup.ts

@@ -0,0 +1,26 @@
+import { Api } from '@icure/api'
+import 'isomorphic-fetch'
+import { hardDeleteGroup } from '@icure/test-setup/groups'
+import { cleanup } from '@icure/test-setup'
+import { webcrypto } from 'crypto'
+
+export {}
+
+const testEnvironment = process.env.TEST_ENVIRONMENT ?? 'docker'
+const composeFileUrl = process.env.COMPOSE_FILE_URL ?? 'https://raw.githubusercontent.com/icure/icure-e2e-test-setup/master/docker-compose-cloud.yaml'
+const adminLogin = process.env.ICURE_TEST_ADMIN_LOGIN ?? 'john'
+const adminPassword = process.env.ICURE_TEST_ADMIN_PWD ?? 'LetMeIn'
+const groupId = process.env.ICURE_TEST_GROUP_ID ?? 'test-group'
+const iCureUrl = process.env.ICURE_TS_TEST_URL ?? 'http://127.0.0.1:16044'
+
+if (testEnvironment === 'docker') {
+  cleanup('test/scratch', composeFileUrl, 'mock', 'haproxy').then(() => {
+    console.log('OK')
+  })
+} else if (testEnvironment === 'acceptance') {
+  Api(iCureUrl, adminLogin, adminPassword, webcrypto as any, fetch).then((api) => {
+    hardDeleteGroup(api, groupId).then(() => {
+      console.log('OK')
+    })
+  })
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "noImplicitThis": true,
+    "allowSyntheticDefaultImports": true,
+    "preserveConstEnums": true,
+    "lib": ["es2017", "es6", "es5", "dom"],
+    "sourceMap": true,
+    "inlineSources": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "baseUrl": "./"
+  },
+  "include": ["index.ts", "node-compat.ts", "icc-api/*", "icc-x-api/**/*", "icc-api/**/*", "icc-x-api/**/*"]
+}

package/icc-x-api/auth/JwtAuthService.d.ts

@@ -1,24 +0,0 @@
-import { AuthService } from './AuthService';
-import { XHR } from '../../icc-api/api/XHR';
-import { IccAuthApi } from '../../icc-api';
-import Header = XHR.Header;
-export declare class JwtAuthService implements AuthService {
-    private readonly authApi;
-    private _error;
-    private _currentPromise;
-    constructor(authApi: IccAuthApi, initialJwt?: {
-        authJwt: string;
-        refreshJwt: string;
-    });
-    getIcureTokens(): Promise<{
-        token: string;
-        refreshToken: string;
-    } | undefined>;
-    get refreshToken(): Promise<string | undefined>;
-    getAuthHeaders(): Promise<Array<Header>>;
-    private _refreshAuthJwt;
-    private _isJwtExpired;
-    private _base64Decode;
-    invalidateHeader(error: Error): void;
-    isInErrorState(): boolean;
-}

package/icc-x-api/auth/JwtAuthService.js

@@ -1,93 +0,0 @@
-"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.JwtAuthService = void 0;
-const XHR_1 = require("../../icc-api/api/XHR");
-const utils_1 = require("../utils");
-class JwtAuthService {
-    constructor(authApi, initialJwt) {
-        this.authApi = authApi;
-        this._error = null;
-        this._currentPromise = Promise.resolve(undefined);
-        if (!!initialJwt) {
-            this._currentPromise = Promise.resolve(initialJwt);
-        }
-    }
-    getIcureTokens() {
-        return this._currentPromise.then((x) => (x ? { token: x.authJwt, refreshToken: x.refreshJwt } : undefined));
-    }
-    get refreshToken() {
-        return this._currentPromise.then((x) => x === null || x === void 0 ? void 0 : x.refreshJwt);
-    }
-    getAuthHeaders() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this._currentPromise
-                .then((x) => {
-                var _a;
-                const authJwt = x === null || x === void 0 ? void 0 : x.authJwt;
-                const refreshJwt = x === null || x === void 0 ? void 0 : x.refreshJwt;
-                if ((!authJwt || this._isJwtExpired(authJwt)) && refreshJwt) {
-                    // If it does not have the JWT, tries to get it
-                    // If the JWT is expired, tries to refresh it
-                    this._currentPromise = this._refreshAuthJwt(refreshJwt).then((updatedTokens) => {
-                        // If here the token is null,
-                        // it goes in a suspension status
-                        if (!updatedTokens.authJwt) {
-                            throw new Error('Your iCure back-end version does not support JWT authentication');
-                        }
-                        return updatedTokens;
-                    });
-                }
-                else {
-                    throw (_a = this._error) !== null && _a !== void 0 ? _a : 'Expired JWT refresh token in pure JwtAuthService incapable of relogging';
-                }
-                return this._currentPromise;
-            })
-                .then((x) => {
-                return (x === null || x === void 0 ? void 0 : x.authJwt) ? [new XHR_1.XHR.Header('Authorization', `Bearer ${x.authJwt}`)] : Promise.reject('Cannot provide auth: No JWT');
-            });
-        });
-    }
-    _refreshAuthJwt(refreshJwt) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // If I do not have a refresh JWT or the refresh JWT is expired,
-            // I have to log in again
-            if (this._isJwtExpired(refreshJwt)) {
-                throw Error('Missing or expired refresh token: please log in again');
-            }
-            else {
-                return this.authApi.refreshAuthenticationJWT(refreshJwt).then((refreshResponse) => ({
-                    authJwt: refreshResponse.token,
-                    refreshJwt: refreshJwt,
-                }));
-            }
-        });
-    }
-    _isJwtExpired(jwt) {
-        const parts = jwt.split('.');
-        if (parts.length !== 3) {
-            return false;
-        }
-        const payload = this._base64Decode(parts[1]);
-        return !('exp' in payload) || payload['exp'] * 1000 < new Date().getTime();
-    }
-    _base64Decode(encodedString) {
-        return JSON.parse((0, utils_1.a2b)(encodedString));
-    }
-    invalidateHeader(error) {
-        this._error = error;
-    }
-    isInErrorState() {
-        return !!this._error;
-    }
-}
-exports.JwtAuthService = JwtAuthService;
-//# sourceMappingURL=JwtAuthService.js.map

package/icc-x-api/auth/JwtAuthService.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"JwtAuthService.js","sourceRoot":"","sources":["../../../icc-x-api/auth/JwtAuthService.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthService } from './AuthService'\nimport { XHR } from '../../icc-api/api/XHR'\nimport { IccAuthApi, OAuthThirdParty } from '../../icc-api'\nimport { LoginCredentials } from '../../icc-api/model/LoginCredentials'\nimport Header = XHR.Header\nimport { a2b } from '../utils'\nimport { AuthenticationResponse } from '../../icc-api/model/AuthenticationResponse'\nimport XHRError = XHR.XHRError\n\nexport class JwtAuthService implements AuthService {\n  private _error: Error | null = null\n  private _currentPromise: Promise<{ authJwt: string; refreshJwt: string } | undefined> = Promise.resolve(undefined as any)\n\n  constructor(private readonly authApi: IccAuthApi, initialJwt?: { authJwt: string; refreshJwt: string }) {\n    if (!!initialJwt) {\n      this._currentPromise = Promise.resolve(initialJwt)\n    }\n  }\n\n  getIcureTokens(): Promise<{ token: string; refreshToken: string } | undefined> {\n    return this._currentPromise.then((x) => (x ? { token: x.authJwt, refreshToken: x.refreshJwt } : undefined))\n  }\n\n  get refreshToken(): Promise<string | undefined> {\n    return this._currentPromise.then((x) => x?.refreshJwt as any)\n  }\n\n  async getAuthHeaders(): Promise<Array<Header>> {\n    return this._currentPromise\n      .then((x) => {\n        const authJwt = x?.authJwt\n        const refreshJwt = x?.refreshJwt\n\n        if ((!authJwt || this._isJwtExpired(authJwt)) && refreshJwt) {\n          // If it does not have the JWT, tries to get it\n          // If the JWT is expired, tries to refresh it\n\n          this._currentPromise = this._refreshAuthJwt(refreshJwt).then((updatedTokens) => {\n            // If here the token is null,\n            // it goes in a suspension status\n            if (!updatedTokens.authJwt) {\n              throw new Error('Your iCure back-end version does not support JWT authentication')\n            }\n\n            return updatedTokens\n          })\n        } else {\n          throw this._error ?? 'Expired JWT refresh token in pure JwtAuthService incapable of relogging'\n        }\n        return this._currentPromise\n      })\n      .then((x) => {\n        return x?.authJwt ? [new XHR.Header('Authorization', `Bearer ${x.authJwt}`)] : Promise.reject('Cannot provide auth: No JWT')\n      })\n  }\n\n  private async _refreshAuthJwt(refreshJwt: string): Promise<{ authJwt: string; refreshJwt: string }> {\n    // If I do not have a refresh JWT or the refresh JWT is expired,\n    // I have to log in again\n    if (this._isJwtExpired(refreshJwt)) {\n      throw Error('Missing or expired refresh token: please log in again')\n    } else {\n      return this.authApi.refreshAuthenticationJWT(refreshJwt).then((refreshResponse) => ({\n        authJwt: refreshResponse.token!,\n        refreshJwt: refreshJwt,\n      }))\n    }\n  }\n\n  private _isJwtExpired(jwt: string): boolean {\n    const parts = jwt.split('.')\n    if (parts.length !== 3) {\n      return false\n    }\n    const payload = this._base64Decode(parts[1])\n    return !('exp' in payload) || payload['exp'] * 1000 < new Date().getTime()\n  }\n\n  private _base64Decode(encodedString: string): any {\n    return JSON.parse(a2b(encodedString))\n  }\n\n  invalidateHeader(error: Error): void {\n    this._error = error\n  }\n\n  isInErrorState(): boolean {\n    return !!this._error\n  }\n}\n"]}

package/icc-x-api/auth/JwtBridgedAuthService.d.ts

@@ -1,27 +0,0 @@
-import { AuthService } from './AuthService';
-import { XHR } from '../../icc-api/api/XHR';
-import { IccAuthApi } from '../../icc-api';
-import Header = XHR.Header;
-export declare class JwtBridgedAuthService implements AuthService {
-    private authApi;
-    private username;
-    private password;
-    private thirdPartyTokens;
-    private _error;
-    private _currentPromise;
-    constructor(authApi: IccAuthApi, username: string, password: string, thirdPartyTokens?: {
-        [thirdParty: string]: string;
-    });
-    get refreshToken(): Promise<string | undefined>;
-    getIcureTokens(): Promise<{
-        token: string;
-        refreshToken: string;
-    } | undefined>;
-    getAuthHeaders(): Promise<Array<Header>>;
-    private _refreshAuthJwt;
-    private _loginAndGetTokens;
-    private _isJwtExpired;
-    private _base64Decode;
-    invalidateHeader(error: Error): void;
-    isInErrorState(): boolean;
-}