oro-sdk-apis 1.14.0 → 1.15.0

package/dist/services/api.d.ts

@@ -2,9 +2,17 @@ import type { AxiosRequestConfig } from 'axios';
 import { AuthRefreshFunc, Tokens } from '../models';
 import { AxiosService } from './axios';
 export declare class APIService extends AxiosService {
+    private useLocalStorage;
     private tokenRefreshFailureCallback?;
     private authRefreshFn?;
-    constructor(config?: AxiosRequestConfig, tokenRefreshFailureCallback?: ((err: Error) => void) | undefined);
+    private tokens;
+    /**
+     * The API Service lets you use an axios API and handles oro backend services authentification via JWT tokens
+     * @param useLocalStorage if set to true, tokens will be stored in localStorage
+     * @param config (optional) an axios config
+     * @param tokenRefreshFailureCallback (optional) callback to call when failing to refresh the auth token
+     */
+    constructor(useLocalStorage: boolean, config?: AxiosRequestConfig, tokenRefreshFailureCallback?: ((err: Error) => void) | undefined);
     setAuthRefreshFn(fn: AuthRefreshFunc): void;
     setTokens(tokens: Tokens): void;
     getTokens(): Tokens;

package/dist/services/apisPracticeManager.d.ts

@@ -0,0 +1,25 @@
+import { AuthTokenResponse, ServiceCollection, ServiceCollectionRequest } from '../models';
+import { GuardService } from './guard';
+/**
+ * This service enables you to handle one authentication token per practice
+ */
+export declare class ApisPracticeManager {
+    private serviceCollReq;
+    private getAuthTokenCbk;
+    private useLocalStorage;
+    private practiceInstances;
+    /**
+     * The constructor
+     * @param serviceCollReq the services to initialize. Only filled urls will get corresponding service to be initialized.
+     * It will be used each time a new practices needs a `ServiceCollection`
+     * @param getAuthTokenCbk the callback function used to get a new JWT token
+     * @param useLocalStorage (default: false) if true store tokens into local storage (only for browsers)
+     */
+    constructor(serviceCollReq: ServiceCollectionRequest, getAuthTokenCbk: (guard: GuardService, practiceUuid: string) => Promise<AuthTokenResponse>, useLocalStorage?: boolean);
+    /**
+     * This function is used to get a `ServiceCollection` associated to a practice. If missing, it will initialize a new `ServiceCollection`.
+     * @param practiceUuid the uuid of the practice
+     * @returns a promise holding a `ServiceCollection`
+     */
+    get(practiceUuid: string): Promise<ServiceCollection>;
+}

package/dist/services/guard.d.ts

@@ -1,5 +1,5 @@
 import type { AxiosAuthRefreshRequestConfig } from 'axios-auth-refresh';
-import { AuthRecoverRequest, AuthTokenRequest, AuthTokenResponse, Base64String, IdentityCreateRequest, IdentityResendConfirmEmailRequest, IdentityResponse, IdentityUpdateRequest, QRCodeResponse, Tokens, Uuid, WhoAmIResponse } from '../models';
+import { AuthRecoverRequest, AuthTokenRequest, AuthTokenResponse, Base64String, IdentityCreateRequest, IdentityResendConfirmEmailRequest, IdentityResponse, IdentityUpdateRequest, M2MTokenRequest, QRCodeResponse, Tokens, Uuid, WhoAmIResponse } from '../models';
 import { APIService } from './api';
 export interface GuardRequestConfig extends AxiosAuthRefreshRequestConfig {
     useRefreshToken: boolean;
@@ -22,6 +22,13 @@ export declare class GuardService {
      * @param tokens
      */
     setTokens(tokens: Tokens): void;
+    /**
+     * Allow to retrieve a M2M token for a service
+     *
+     * @param req The credentials required to get an access token
+     * @returns AuthTokenResponse
+     */
+    m2mToken(req: M2MTokenRequest): Promise<AuthTokenResponse>;
     /**
      * Allow to retrieve an access token and a refresh token in order
      * to do authenticated request afterward

package/dist/services/index.d.ts

@@ -1,4 +1,5 @@
 export * from './api';
+export * from './apisPracticeManager';
 export * from './axios';
 export * from './consult';
 export * from './diagnosis';

package/package.json

@@ -1,5 +1,5 @@
 {
-    "version": "1.14.0",
+    "version": "1.15.0",
     "main": "dist/index.js",
     "typings": "dist/index.d.ts",
     "files": [

package/src/helpers/hash.ts

@@ -0,0 +1,11 @@
+import { sha256 } from 'hash.js'
+import { Buffer } from 'buffer/'
+
+/**
+ * This function return a base64 string representation of a hashed string
+ * @param value the string to hash
+ * @returns a base64 string representation of a hashed value
+ */
+export function hashToBase64String(value: string): string {
+    return Buffer.from(sha256().update(value).digest('hex'), 'hex').toString('base64')
+}

package/src/helpers/index.ts

@@ -0,0 +1,2 @@
+export * from './hash'
+export * from './init'

package/src/helpers/init.ts

@@ -0,0 +1,47 @@
+import { ServiceCollection, ServiceCollectionRequest } from '../models'
+import {
+    APIService,
+    ConsultService,
+    DiagnosisService,
+    GuardService,
+    PracticeService,
+    TellerService,
+    VaultService,
+    WorkflowService,
+} from '../services'
+
+/**
+ * This function is used to initialize services with a provided url
+ * @param services an object containing the url of the services to init
+ * @param authenticationCallback (optional) the authentification callback. Called when the token were not able to be refreshed.
+ * @param useLocalStorage (default: true) if true store tokens into local storage (only for browsers)
+ * @returns an instance of each services with a provided url
+ */
+export const init = (
+    services: ServiceCollectionRequest,
+    authenticationCallback?: (err: Error, practiceUuid?: string) => void,
+    useLocalStorage = true
+): ServiceCollection => {
+    const {
+        tellerBaseURL,
+        practiceBaseURL,
+        consultBaseURL,
+        vaultBaseURL,
+        guardBaseURL,
+        workflowBaseURL,
+        diagnosisBaseURL,
+    } = services
+
+    const apiService = new APIService(useLocalStorage, undefined, authenticationCallback)
+
+    return {
+        apiService,
+        tellerService: tellerBaseURL ? new TellerService(apiService, tellerBaseURL) : undefined,
+        practiceService: practiceBaseURL ? new PracticeService(apiService, practiceBaseURL) : undefined,
+        consultService: consultBaseURL ? new ConsultService(apiService, consultBaseURL) : undefined,
+        vaultService: vaultBaseURL ? new VaultService(apiService, vaultBaseURL) : undefined,
+        guardService: guardBaseURL ? new GuardService(apiService, guardBaseURL) : undefined,
+        workflowService: workflowBaseURL ? new WorkflowService(apiService, workflowBaseURL) : undefined,
+        diagnosisService: diagnosisBaseURL ? new DiagnosisService(apiService, diagnosisBaseURL) : undefined,
+    }
+}

package/src/index.ts

@@ -1,56 +1,6 @@
-import {
-    APIService,
-    TellerService,
-    VaultService,
-    GuardService,
-    PracticeService,
-    ConsultService,
-    WorkflowService,
-    DiagnosisService,
-} from './services'
-
-/**
- * This function is used to initialize services with a provided url
- * @param services an object containing the url of the services to init
- * @param (optional) authenticationCallback the authentification callback 
- * @returns an instance of each services with a provided url
- */
-const init = (
-    services: {
-        tellerBaseURL?: string
-        vaultBaseURL?: string
-        guardBaseURL?: string
-        practiceBaseURL?: string
-        consultBaseURL?: string
-        workflowBaseURL?: string
-        diagnosisBaseURL?: string
-    },
-    authenticationCallback?: (err: Error) => void
-) => {
-    const {
-        tellerBaseURL,
-        practiceBaseURL,
-        consultBaseURL,
-        vaultBaseURL,
-        guardBaseURL,
-        workflowBaseURL,
-        diagnosisBaseURL,
-    } = services
-
-    const apiService = new APIService(undefined, authenticationCallback)
-
-    return {
-        tellerService: tellerBaseURL ? new TellerService(apiService, tellerBaseURL) : undefined,
-        practiceService: practiceBaseURL ? new PracticeService(apiService, practiceBaseURL) : undefined,
-        consultService: consultBaseURL ? new ConsultService(apiService, consultBaseURL) : undefined,
-        vaultService: vaultBaseURL ? new VaultService(apiService, vaultBaseURL) : undefined,
-        guardService: guardBaseURL ? new GuardService(apiService, guardBaseURL) : undefined,
-        workflowService: workflowBaseURL ? new WorkflowService(apiService, workflowBaseURL) : undefined,
-        diagnosisService: diagnosisBaseURL ? new DiagnosisService(apiService, diagnosisBaseURL) : undefined,
-    }
-}
-
+import { init } from './helpers'
 
+export * from './helpers'
 export * from './models'
 export * from './services'
 export default init

package/src/models/guard.ts

@@ -1,8 +1,6 @@
 import { Uuid, Base64String, TokenData, RFC3339Date, Url } from './'
 
-export type AuthRefreshFunc = (
-    refreshToken?: string
-) => Promise<AuthTokenResponse>
+export type AuthRefreshFunc = (refreshToken?: string) => Promise<AuthTokenResponse>
 export interface Tokens {
     accessToken?: string
     refreshToken?: string
@@ -17,10 +15,21 @@ export interface AuthTokenRequest {
 export interface AuthTokenResponse {
     accessToken: string
     tokenType: string
-    refreshToken: string
+    refreshToken?: string
     expiresIn: number
 }
 
+/**
+ * This interface is used to request a M2M token as a service
+ */
+export interface M2MTokenRequest {
+    clientId: string
+    clientSecret: string
+    requestedScopes: string[]
+    practiceUuid: string
+}
+
+
 export interface AuthRecoverRequest {
     practiceUuid: string
     email: string

package/src/models/index.ts

@@ -1,7 +1,9 @@
 export * from './consult'
 export * from './diagnosis'
 export * from './error'
+export * from './external'
 export * from './guard'
+export * from './init'
 export * from './practice'
 export * from './shared'
 export * from './vault'

package/src/models/init.ts

@@ -0,0 +1,37 @@
+import {
+    APIService,
+    ConsultService,
+    DiagnosisService,
+    GuardService,
+    PracticeService,
+    TellerService,
+    VaultService,
+    WorkflowService,
+} from '../services'
+
+/**
+ * This interface represents a collection of service urls you need to initialize
+ */
+export interface ServiceCollectionRequest {
+    tellerBaseURL?: string
+    vaultBaseURL?: string
+    guardBaseURL?: string
+    practiceBaseURL?: string
+    consultBaseURL?: string
+    workflowBaseURL?: string
+    diagnosisBaseURL?: string
+}
+
+/**
+ * This interface represents a collection of service
+ */
+export interface ServiceCollection {
+    apiService: APIService
+    tellerService?: TellerService
+    practiceService?: PracticeService
+    consultService?: ConsultService
+    vaultService?: VaultService
+    guardService?: GuardService
+    workflowService?: WorkflowService
+    diagnosisService?: DiagnosisService
+}

package/src/services/api.ts

@@ -4,11 +4,18 @@ import { AuthRefreshFunc, Tokens } from '../models'
 import { AxiosService } from './axios'
 import { GuardRequestConfig } from './guard'
 
-
 export class APIService extends AxiosService {
     private authRefreshFn?: AuthRefreshFunc
+    private tokens: Tokens = {}
 
+    /**
+     * The API Service lets you use an axios API and handles oro backend services authentification via JWT tokens
+     * @param useLocalStorage if set to true, tokens will be stored in localStorage
+     * @param config (optional) an axios config
+     * @param tokenRefreshFailureCallback (optional) callback to call when failing to refresh the auth token
+     */
     constructor(
+        private useLocalStorage: boolean,
         config?: AxiosRequestConfig,
         private tokenRefreshFailureCallback?: (err: Error) => void
     ) {
@@ -16,7 +23,7 @@ export class APIService extends AxiosService {
         const self = this
 
         this.axios.interceptors.request.use(
-            config => {
+            (config) => {
                 const token = (config as GuardRequestConfig).useRefreshToken
                     ? self.getTokens().refreshToken
                     : self.getTokens().accessToken
@@ -25,37 +32,40 @@ export class APIService extends AxiosService {
                     ...config.headers,
                     Authorization: `Bearer ${token}`,
                 }
-                return config;
+                return config
             },
-            error => {
+            (error) => {
                 Promise.reject(error)
             }
-        );
+        )
 
-        createAuthRefreshInterceptor(this.axios, async function (failedRequest) {
-            if (self.authRefreshFn) {
-                try {
-                    let tokenResp = await self.authRefreshFn(self.getTokens().refreshToken)
-                    self.setTokens({
-                        accessToken: tokenResp.accessToken,
-                        refreshToken: tokenResp.refreshToken
-                    })
-                    failedRequest.response.config.headers['Authorization'] = `Bearer ${self.getTokens().accessToken}`
-                    return Promise.resolve()
-                    
-                } catch (e) {
-                    console.error('an error occured while refreshing tokens (notifying callback)', e)
-                    if (self.tokenRefreshFailureCallback)
-                    self.tokenRefreshFailureCallback(failedRequest)
-                    return Promise.resolve() // We keep it like that. Otherwise, it seems to break the api service will it is not needed
-                    // return Promise.reject(e) 
+        createAuthRefreshInterceptor(
+            this.axios,
+            async function (failedRequest) {
+                if (self.authRefreshFn) {
+                    try {
+                        let tokenResp = await self.authRefreshFn(self.getTokens().refreshToken)
+                        self.setTokens({
+                            accessToken: tokenResp.accessToken,
+                            refreshToken: tokenResp.refreshToken,
+                        })
+                        failedRequest.response.config.headers['Authorization'] = `Bearer ${
+                            self.getTokens().accessToken
+                        }`
+                        return Promise.resolve()
+                    } catch (e) {
+                        console.error('an error occured while refreshing tokens (notifying callback)', e)
+                        if (self.tokenRefreshFailureCallback) self.tokenRefreshFailureCallback(failedRequest)
+                        return Promise.resolve() // We keep it like that. Otherwise, it seems to break the api service will it is not needed
+                        // return Promise.reject(e)
+                    }
                 }
-            }
-            console.error('The request could not refresh the token (authRefreshFn was not set)', failedRequest)
-            return Promise.resolve() // We keep it like that. Otherwise, it seems to break the api service will it is not needed
-            // return Promise.reject(failedRequest)
-
-        }, { statusCodes: [401, 403] })
+                console.error('The request could not refresh the token (authRefreshFn was not set)', failedRequest)
+                return Promise.resolve() // We keep it like that. Otherwise, it seems to break the api service will it is not needed
+                // return Promise.reject(failedRequest)
+            },
+            { statusCodes: [401, 403] }
+        )
     }
 
     public setAuthRefreshFn(fn: AuthRefreshFunc) {
@@ -63,15 +73,22 @@ export class APIService extends AxiosService {
     }
 
     public setTokens(tokens: Tokens) {
-        localStorage.setItem('tokens', JSON.stringify(tokens))
+        if (this.useLocalStorage) {
+            localStorage.setItem('tokens', JSON.stringify(tokens))
+        }
+        this.tokens = tokens
     }
 
     public getTokens(): Tokens {
-        let tokens : Tokens = {}
-        const item = localStorage.getItem('tokens')
-        if (item) {
-            tokens = JSON.parse(item)
+        if (this.useLocalStorage) {
+            let tokens: Tokens = {}
+            const item = localStorage.getItem('tokens')
+            if (item) {
+                tokens = JSON.parse(item)
+            }
+            return tokens
+        } else {
+            return this.tokens
         }
-        return tokens
     }
 }

package/src/services/apisPracticeManager.ts

@@ -0,0 +1,52 @@
+import { init } from '../helpers'
+import { AuthTokenResponse, ServiceCollection, ServiceCollectionRequest } from '../models'
+import { GuardService } from './guard'
+
+/**
+ * This service enables you to handle one authentication token per practice
+ */
+export class ApisPracticeManager {
+    private practiceInstances = new Map<string, ServiceCollection>()
+
+    /**
+     * The constructor
+     * @param serviceCollReq the services to initialize. Only filled urls will get corresponding service to be initialized.
+     * It will be used each time a new practices needs a `ServiceCollection`
+     * @param getAuthTokenCbk the callback function used to get a new JWT token
+     * @param useLocalStorage (default: false) if true store tokens into local storage (only for browsers)
+     */
+    constructor(
+        private serviceCollReq: ServiceCollectionRequest,
+        private getAuthTokenCbk: (guard: GuardService, practiceUuid: string) => Promise<AuthTokenResponse>,
+        private useLocalStorage = false
+    ) {}
+
+    /**
+     * This function is used to get a `ServiceCollection` associated to a practice. If missing, it will initialize a new `ServiceCollection`.
+     * @param practiceUuid the uuid of the practice
+     * @returns a promise holding a `ServiceCollection`
+     */
+    public async get(practiceUuid: string): Promise<ServiceCollection> {
+        const practiceInstance = this.practiceInstances.get(practiceUuid)
+        if (practiceInstance) return practiceInstance
+
+        const newPracticeInstance = init(this.serviceCollReq, undefined, this.useLocalStorage)
+
+        // Create one auth token callback per practice since the practice uuid needs to change
+        const authTokenFunc = async () => {
+            if (newPracticeInstance.guardService) {
+                console.log(`\x1b[36m[Auth] Refresh auth called (practiceUuid: ${practiceUuid})\x1b[36m`)
+                return await this.getAuthTokenCbk(newPracticeInstance.guardService, practiceUuid)
+            } else {
+                throw Error('[Auth] Unable to refresh token guard service is undefined')
+            }
+        }
+
+        // Set the refresh tokens callback
+        newPracticeInstance.apiService.setAuthRefreshFn(authTokenFunc)
+
+        this.practiceInstances.set(practiceUuid, newPracticeInstance)
+
+        return newPracticeInstance
+    }
+}

package/src/services/guard.ts

@@ -16,6 +16,7 @@ import {
     IdentityResendConfirmEmailRequest,
     IdentityResponse,
     IdentityUpdateRequest,
+    M2MTokenRequest,
     QRCodeRequest,
     QRCodeResponse,
     Tokens,
@@ -32,7 +33,7 @@ export class GuardService {
     private whoAmICache: Record<string, WhoAmIResponse>
 
     constructor(private api: APIService, private baseURL: string) {
-        this.api.setAuthRefreshFn(this.authRefresh.bind(this))
+        this.api.setAuthRefreshFn(this.authRefresh.bind(this)) // This is the default behavior for User JWT tokens. If you want other kind of refresh you shall overwrite this call
         this.identityCache = {}
         this.whoAmICache = {}
     }
@@ -52,6 +53,46 @@ export class GuardService {
         this.api.setTokens({ ...this.api.getTokens(), ...tokens })
     }
 
+    /**
+     * Allow to retrieve a M2M token for a service
+     *
+     * @param req The credentials required to get an access token
+     * @returns AuthTokenResponse
+     */
+    public async m2mToken(req: M2MTokenRequest): Promise<AuthTokenResponse> {
+        let resp: AuthTokenResponse | undefined
+
+        try {
+            let config: AxiosAuthRefreshRequestConfig = {
+                skipAuthRefresh: true,
+            }
+
+            resp = await this.api.post<AuthTokenResponse>(`${this.baseURL}/v1/m2m/token`, req, config)
+
+            this.api.setTokens({
+                accessToken: resp.accessToken,
+            })
+        } catch (e) {
+            console.error('Error while posting m2m token:', e)
+
+            if ((e as any).isAxiosError) {
+                const code = (e as AxiosError).response?.status
+                switch (code) {
+                    case 400:
+                        throw new AuthenticationBadRequest()
+                    case 500:
+                        throw new AuthenticationServerError()
+                    case 401:
+                    default:
+                        throw new AuthenticationFailed()
+                }
+            }
+            throw new AuthenticationFailed()
+        }
+
+        return resp
+    }
+
     /**
      * Allow to retrieve an access token and a refresh token in order
      * to do authenticated request afterward
@@ -74,6 +115,8 @@ export class GuardService {
                 refreshToken: resp.refreshToken,
             })
         } catch (e) {
+            console.error('Error while posting auth token:', e)
+
             if ((e as any).isAxiosError) {
                 const code = (e as AxiosError).response?.status
                 switch (code) {
@@ -237,7 +280,7 @@ export class GuardService {
      * @returns IdentityResponse
      */
     public async identityGetByCustomerEmail(email: string): Promise<IdentityResponse> {
-        return this.identityGetByHash(email.substring(email.indexOf('+')+1, email.indexOf('@')))
+        return this.identityGetByHash(email.substring(email.indexOf('+') + 1, email.indexOf('@')))
     }
 
     /**
@@ -252,9 +295,8 @@ export class GuardService {
         //call (ie: /v1/mapping/[b64Hash]) which would return a blob to decrypt
         //which would contain the real identityID to call IdentityGet with.
 
-
         //The hash comes in base64 format but it isn't URL safe soe we have to convert
         //to base64URL (see https://en.wikipedia.org/wiki/Base64#The_URL_applications)
-        return this.identityGet(b64Hash.replace('+','-').replace('/','_'))
+        return this.identityGet(b64Hash.replace('+', '-').replace('/', '_'))
     }
 }

package/src/services/index.ts

@@ -1,4 +1,5 @@
 export * from './api'
+export * from './apisPracticeManager'
 export * from './axios'
 export * from './consult'
 export * from './diagnosis'

package/src/services/practice.ts

@@ -1,5 +1,4 @@
-import { Buffer } from 'buffer/'
-import { sha256 } from 'hash.js'
+import { hashToBase64String } from '../helpers'
 import { ConsultRequestMetadata, PracticeAccount, Uuid } from '../models'
 import {
     Assignment,
@@ -175,7 +174,7 @@ export class PracticeService {
      * @returns a hashed email
      */
     public getPaymentIntentHashedEmail(email: string): string {
-        return Buffer.from(sha256().update(email.toLowerCase()).digest('hex'), 'hex').toString('base64')
+        return hashToBase64String(email.toLowerCase())
     }
 
     /**