@emilgroup/customer-sdk-node 1.1.1 → 1.4.0

package/base.ts

@@ -17,6 +17,7 @@ import { Configuration } from "./configuration";
 // Some imports not used depending on template conditions
 // @ts-ignore
 import globalAxios, { AxiosPromise, AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { InitiateAuthResponseClass, RespondToAuthChallengeClass, RespondToAuthChallengeRequestDto } from "./models";
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -69,6 +70,7 @@ export class BaseAPI {
     protected configuration: Configuration | undefined;
     private username?: string;
     private password?: string;
+    private isCustomerToken = false;
 
     constructor(configuration?: Configuration, protected basePath: string = BASE_PATH, protected axios: AxiosInstance = globalAxios) {
         if (configuration) {
@@ -83,35 +85,169 @@ export class BaseAPI {
         this.attachInterceptor(axios);
     }
 
+    async initialize(env: Environment = Environment.Production) {
+        this.configuration.basePath = env;
+
+        await this.loadCredentials();
+
+        if (this.username) {
+            await this.authorize(this.username, this.password);
+            this.password = null; // to avoid keeping password loaded in memory.
+        }
+    }
+
+    private async loadCredentials() {
+        try {
+            await this.readConfigFile();
+        } catch (error) {
+            console.warn(`No credentials file found. Check that ${filePath} exists.`);
+        }
+
+        this.readEnvVariables();
+
+        if (!this.username) {
+            console.info(`No credentials found in credentials file or environment variables. Either provide some or use 
+                authorize() function.`);
+        }
+    }
+
+    private async readConfigFile() {
+        const file = await fs.promises.readFile(filePath, 'utf-8');
+
+        const lines = file.split(os.EOL)
+            .filter(Boolean);
+
+        lines.forEach((line: string) => {
+            if (line.startsWith(KEY_USERNAME)) {
+                this.username = line.length > KEY_USERNAME.length + 1 ? line.substring(KEY_USERNAME.length + 1) : '';
+            } else if (line.startsWith(KEY_PASSWORD)) {
+                this.password = line.length > KEY_PASSWORD.length + 1 ? line.substring(KEY_PASSWORD.length + 1) : '';
+            }
+        });
+    }
+
+    private readEnvVariables(): boolean {
+        if (process.env.EMIL_USERNAME) {
+            this.username = process.env.EMIL_USERNAME;
+            this.password = process.env.EMIL_PASSWORD || '';
+
+            return true;
+        }
+
+        return false;
+    }
+
     selectEnvironment(env: Environment) {
         this.configuration.basePath = env;
     }
 
-    async authorize(username: string, password: string, tenantSlug: string): Promise<void> {
+    async authorize(username: string, password: string): Promise<void> {
         const options: AxiosRequestConfig = {
             method: 'POST',
-            url: `${this.configuration.basePath}/v1/customers/login`,
-            headers: {'Content-Type': 'application/json'},
+            url: `${this.configuration.basePath}/authservice/v1/login`,
+            headers: { 'Content-Type': 'application/json' },
             data: {
-                username, 
+                username,
                 password,
-                tenantSlug,
             },
             withCredentials: true,
         };
 
         const response = await globalAxios.request<LoginClass>(options);
-        
+
         const { data: { accessToken } } = response;
         const refreshToken = this.extractRefreshToken(response)
 
         this.configuration.username = username;
-        this.configuration.tenantSlug = tenantSlug;
         this.configuration.accessToken = `Bearer ${accessToken}`;
         this.configuration.refreshToken = refreshToken;
     }
 
-    async refreshTokenInternal(): Promise<string> {
+    async initiateAuthorization(username: string, password: string, tenantSlug: string): 
+        Promise<AxiosResponse<InitiateAuthResponseClass>> {
+        const options: AxiosRequestConfig = {
+            method: 'POST',
+            url: `${this.configuration.basePath}/v1/customers/auth/initiate`,
+            headers: { 'Content-Type': 'application/json' },
+            data: {
+                authFlow: "USER_PASSWORD_AUTH",
+                authParameters: {
+                    "USERNAME": username,
+                    "PASSWORD": password,
+                }, 
+                tenantSlug,
+            },
+            withCredentials: true,
+        };
+
+        const response = await globalAxios.request<InitiateAuthResponseClass>(options);
+
+        if (response.data.authenticationResult) {
+            const { accessToken } = response.data.authenticationResult;
+            const refreshToken = this.extractRefreshToken(response)
+    
+            this.configuration.username = username;
+            this.configuration.tenantSlug = tenantSlug;
+            this.configuration.accessToken = `Bearer ${accessToken}`;
+            this.configuration.refreshToken = refreshToken;
+
+            this.isCustomerToken = true;
+        }
+
+        return response;
+    }
+
+    async respondToAuthorizationChallenge(respondToAuthChallengeRequestDto: RespondToAuthChallengeRequestDto): 
+        Promise<AxiosResponse<RespondToAuthChallengeClass>> {
+        const options: AxiosRequestConfig = {
+            method: 'POST',
+            url: `${this.configuration.basePath}/v1/customers/auth/respond`,
+            headers: { 'Content-Type': 'application/json' },
+            data: {
+                ...respondToAuthChallengeRequestDto,
+            },
+            withCredentials: true,
+        };
+
+        const response = await globalAxios.request<RespondToAuthChallengeClass>(options);
+
+        if (response.data.authenticationResult) {
+            const { accessToken } = response.data.authenticationResult;
+            const refreshToken = this.extractRefreshToken(response)
+    
+            this.configuration.accessToken = `Bearer ${accessToken}`;
+            this.configuration.refreshToken = refreshToken;
+
+            this.isCustomerToken = true;
+        }
+
+        return response;
+    }
+
+    async refreshTokenTenant(): Promise<string> {
+        const { username, refreshToken } = this.configuration;
+
+        if (!username || !refreshToken) {
+            return '';
+        }
+
+        const options: AxiosRequestConfig = {
+            method: 'POST',
+            url: `${this.configuration.basePath}/authservice/v1/refresh-token`,
+            headers: {
+                'Content-Type': 'application/json',
+                Cookie: refreshToken,
+            },
+            data: { username: username },
+            withCredentials: true,
+        };
+
+        const { data: { accessToken } } = await globalAxios.request<LoginClass>(options);
+
+        return accessToken;
+    }
+
+    async refreshTokenCustomer(): Promise<string> {
         const { username, refreshToken, tenantSlug } = this.configuration;
 
         if (!username || !refreshToken) {
@@ -156,7 +292,12 @@ export class BaseAPI {
                     if (err.response.status === 401 && !originalConfig._retry) {
                         originalConfig._retry = true;
                         try {
-                            const tokenString = await this.refreshTokenInternal();
+                            let tokenString: string;
+                            if (this.isCustomerToken) {
+                                tokenString = await this.refreshTokenCustomer();
+                            } else {
+                                tokenString = await this.refreshTokenTenant();
+                            }
                             const accessToken = `Bearer ${tokenString}`;
 
                             const localVarHeaderParameter = {} as any;