@emilgroup/translation-sdk 1.0.1-beta.4 → 1.1.0

package/api.ts

@@ -15,15 +15,17 @@
 
 import { Configuration } from './configuration';
 import globalAxios, { AxiosPromise, AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
+// URLSearchParams not necessarily used
+// @ts-ignore
+import { URL, URLSearchParams } from 'url';
+import FormData from 'form-data'
 // Some imports not used depending on template conditions
 // @ts-ignore
 import { DUMMY_BASE_URL, assertParamExists, setApiKeyToObject, setBasicAuthToObject, setBearerAuthToObject, setOAuthToObject, setSearchParams, serializeDataIfNeeded, toPathString, createRequestFunction } from './common';
 // @ts-ignore
 import { BASE_PATH, COLLECTION_FORMATS, RequestArgs, BaseAPI, RequiredError } from './base';
-import { DefaultApi } from './api';
 import { TranslationApi } from './api';
 
 
-export * from './api/default-api';
 export * from './api/translation-api';
 

package/base.ts

@@ -14,13 +14,20 @@
 
 
 import { Configuration } from "./configuration";
-import { defaultStorage } from "./common";
 // Some imports not used depending on template conditions
 // @ts-ignore
 import globalAxios, { AxiosPromise, AxiosInstance, AxiosRequestConfig, AxiosResponse } from 'axios';
-
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
 
 export const BASE_PATH = "https://apiv2.emil.de".replace(/\/+$/, "");
+const CONFIG_DIRECTORY = '.emil';
+const CONFIG_FILENAME = 'credentials';
+const KEY_USERNAME = 'emil_username';
+const KEY_PASSWORD = 'emil_password';
+
+const filePath = os.homedir() + path.sep + CONFIG_DIRECTORY + path.sep + CONFIG_FILENAME;
 /**
  *
  * @export
@@ -34,25 +41,13 @@ export const COLLECTION_FORMATS = {
 
 export interface LoginClass {
     accessToken: string;
-    permissions: string;
-}
-
-export interface SwitchWorkspaceRequest {
-    username: string;
-    targetWorkspace: string;
-}
-
-export interface SwitchWorkspaceResponseClass {
-    accessToken: string;
-    permissions: string;
+    permissions: Array<string>;
 }
 
 export enum Environment {
     Production = 'https://apiv2.emil.de',
     Test = 'https://apiv2-test.emil.de',
-    Staging = 'https://apiv2-staging.emil.de',
     Development = 'https://apiv2-dev.emil.de',
-    ProductionZurich = 'https://eu-central-2.apiv2.emil.de',
 }
 
 let _retry_count = 0
@@ -72,14 +67,7 @@ export interface RequestArgs {
     options: AxiosRequestConfig;
 }
 
-interface TokenData {
-    accessToken?: string;
-    username?: string;
-    permissions?: string;
-}
-
 const NETWORK_ERROR_MESSAGE = "Network Error";
-const TOKEN_DATA = 'APP_TOKEN';
 
 /**
  *
@@ -87,54 +75,80 @@ const TOKEN_DATA = 'APP_TOKEN';
  * @class BaseAPI
  */
 export class BaseAPI {
-    protected configuration: Configuration | undefined;
-    private tokenData?: TokenData;
-
-    constructor(configuration?: Configuration,
-        protected basePath: string = BASE_PATH, 
-        protected axios: AxiosInstance = globalAxios) {
-        
-        this.loadTokenData();
+    protected configuration: Configuration;
+    private username?: string;
+    private password?: string;
 
+    constructor(configuration?: Configuration, protected basePath: string = BASE_PATH, protected axios: AxiosInstance = globalAxios) {
         if (configuration) {
-            const { accessToken } = this.tokenData;
             this.configuration = configuration;
             this.basePath = configuration.basePath || this.basePath;
-
-            // Use config token if provided, otherwise use tokenData token
-            const configToken = this.configuration.accessToken;
-            const storedToken = accessToken ? `Bearer ${accessToken}` : '';
-            this.configuration.accessToken = configToken || storedToken;
         } else {
-            const { accessToken, username } = this.tokenData;
-
             this.configuration = new Configuration({
                 basePath: this.basePath,
-                accessToken: accessToken ? `Bearer ${accessToken}` : '',
-                username,
             });
         }
 
         this.attachInterceptor(axios);
     }
 
-    selectEnvironment(env: Environment) {
-        this.selectBasePath(env);
+    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.`);
+        }
     }
 
-    selectBasePath(path: string) {
-        this.configuration.basePath = path;
+    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) : '';
+            }
+        });
     }
 
-    getPermissions(): Array<string> {
-        if (!this.tokenData?.permissions) {
-            return [];
+    private readEnvVariables(): boolean {
+        if (process.env.EMIL_USERNAME) {
+            this.username = process.env.EMIL_USERNAME;
+            this.password = process.env.EMIL_PASSWORD || '';
+
+            return true;
         }
 
-        return this.tokenData.permissions.split(',');
+        return false;
+    }
+    
+    selectEnvironment(env: Environment) {
+        this.configuration.basePath = env;
     }
 
-    async authorize(username: string, password: string, targetWorkspace?: string): Promise<void> {
+    async authorize(username: string, password: string): Promise<void> {
         const options: AxiosRequestConfig = {
             method: 'POST',
             url: `${this.configuration.basePath}/authservice/v1/login`,
@@ -148,100 +162,50 @@ export class BaseAPI {
 
         const response = await globalAxios.request<LoginClass>(options);
 
-        const { data: { accessToken, permissions } } = response;
-
+        const { data: { accessToken } } = response;
         this.configuration.username = username;
         this.configuration.accessToken = `Bearer ${accessToken}`;
-        this.tokenData.username = username;
-        this.tokenData.accessToken = accessToken;
-        this.tokenData.permissions = permissions;
 
-        // Switch workspace if provided
-        if (targetWorkspace) {
-            await this.switchWorkspace(targetWorkspace);
-        } else {
-            // Only store if no workspace switch (since switchWorkspace will store after switching)
-            this.storeTokenData({
-                ...this.tokenData
-            });
-        }
+        const refreshToken = this.extractRefreshToken(response)
+        this.configuration.refreshToken = refreshToken;
     }
 
-    async switchWorkspace(targetWorkspace: string): Promise<void> {
-        const options: AxiosRequestConfig = {
-            method: 'POST',
-            url: `${this.configuration.basePath}/authservice/v1/workspaces/switch`,
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.configuration.accessToken}`,
-            },
-            data: {
-                username: this.configuration.username,
-                targetWorkspace,
-            } as SwitchWorkspaceRequest,
-            withCredentials: true,
-        };
-
-        const response = await globalAxios.request<SwitchWorkspaceResponseClass>(options);
-
-        const { data: { accessToken, permissions } } = response;
+    async refreshTokenInternal(): Promise<string> {
+        const { username, refreshToken } = this.configuration;
         
-        this.configuration.accessToken = `Bearer ${accessToken}`;
-        this.tokenData.accessToken = accessToken;
-        this.tokenData.permissions = permissions;
 
-        this.storeTokenData({
-            ...this.tokenData
-        });
-    }
-
-    async refreshTokenInternal(): Promise<LoginClass> {
-        const { username } = this.configuration;
-
-        if (!username) {
-            throw new Error('Failed to refresh token.');
+        if (!username || !refreshToken) {
+            return '';
         }
 
-        const refreshTokenAxios = globalAxios.create()
-        refreshTokenAxios.interceptors.response.use(response => {
-          const { permissions } = response.data;
-
-          this.tokenData.permissions = permissions;
-          this.storeTokenData(this.tokenData);
-
-          return response;
-        })
-
         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 response = await refreshTokenAxios.request<LoginClass>(options);
-        return response.data;
-    }
+        const { data: { accessToken } } = await globalAxios.request<LoginClass>(options);
 
-    private storeTokenData(tokenData?: TokenData) {
-        if (typeof window !== 'undefined') {
-            defaultStorage().set<TokenData>(TOKEN_DATA, tokenData);
-        }
+        return accessToken;
     }
 
-    public loadTokenData() {
-        if (typeof window !== 'undefined') {
-            this.tokenData = defaultStorage().get<TokenData>(TOKEN_DATA) || {};
-        } else {
-            this.tokenData = {};
+    private extractRefreshToken(response: AxiosResponse): string {
+        if (response.headers && response.headers['set-cookie']
+            && response.headers['set-cookie'].length > 0) {
+
+            return `${response.headers['set-cookie'][0].split(';')[0]};`;
         }
+
+        return '';
     }
 
-    public cleanTokenData() {
-        this.storeTokenData(null);
+    getConfiguration(): Configuration {
+        return this.configuration;
     }
 
     private attachInterceptor(axios: AxiosInstance) {
@@ -251,26 +215,19 @@ export class BaseAPI {
             },
             async (err) => {
                 let originalConfig = err.config;
-                if (err.response && !(err.response instanceof XMLHttpRequest)) { // sometimes buggy and is of type request
+                if (err.response) {
                     // Access Token was expired
-                    if ((err.response.status === 401 || err.response.status === 403)
-                        && !originalConfig._retry) {
+                    if (err.response.status === 401 && !originalConfig._retry) {
                         originalConfig._retry = true;
                         try {
-                            const { accessToken: tokenString, permissions } = await this.refreshTokenInternal();
+                            const tokenString = await this.refreshTokenInternal();
                             const accessToken = `Bearer ${tokenString}`;
-                            this.tokenData.permissions = permissions;
 
-                            delete originalConfig.headers['Authorization']
-
-                            originalConfig.headers['Authorization'] = accessToken;
+                            originalConfig.headers['Authorization'] = `Bearer ${accessToken}`
 
                             this.configuration.accessToken = accessToken;
-                            this.tokenData.accessToken = tokenString;
-
-                            this.storeTokenData(this.tokenData);
 
-                            return axios(originalConfig);
+                            return axios.request(originalConfig);
                         } catch (_error) {
                             if (_error.response && _error.response.data) {
                                 return Promise.reject(_error.response.data);
@@ -278,23 +235,23 @@ export class BaseAPI {
                             return Promise.reject(_error);
                         }
                     }
-                } else if (err.message === NETWORK_ERROR_MESSAGE
+                    if (err.response.status === 403 && err.response.data) {
+                        return Promise.reject(err.response.data);
+                    }
+                } else if(err.message === NETWORK_ERROR_MESSAGE 
+                    && err.isAxiosError
                     && originalConfig.headers.hasOwnProperty('Authorization')
                     && _retry_count < 4
-                ) {
+                ){ 
                     _retry_count++;
                     try {
-                        const { accessToken: tokenString, permissions } = await this.refreshTokenInternal();
+                        const tokenString = await this.refreshTokenInternal();
                         const accessToken = `Bearer ${tokenString}`;
-                        this.tokenData.permissions = permissions;
 
                         _retry = true;
-                        originalConfig.headers['Authorization'] = accessToken;
+                        originalConfig.headers['Authorization'] = accessToken; 
 
                         this.configuration.accessToken = accessToken;
-                        this.tokenData.accessToken = tokenString;
-
-                        this.storeTokenData(this.tokenData);
 
                         return axios.request({
                             ...originalConfig,
@@ -304,7 +261,7 @@ export class BaseAPI {
                             return Promise.reject(_error.response.data);
                         }
                         return Promise.reject(_error);
-                    }
+                    }                    
                 }
                 return Promise.reject(err);
             }
@@ -319,7 +276,7 @@ export class BaseAPI {
  * @extends {Error}
  */
 export class RequiredError extends Error {
-    override name: "RequiredError" = "RequiredError";
+    name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
         super(msg);
     }

package/common.ts

@@ -16,6 +16,7 @@
 import { Configuration } from "./configuration";
 import { RequiredError, RequestArgs } from "./base";
 import { AxiosInstance, AxiosResponse } from 'axios';
+import { URL, URLSearchParams } from 'url';
 /**
  *
  * @export
@@ -65,7 +66,7 @@ export const setBearerAuthToObject = async function (object: any, configuration?
         const accessToken = typeof configuration.accessToken === 'function'
             ? await configuration.accessToken()
             : await configuration.accessToken;
-        object["Authorization"] = configuration.getBearerToken(accessToken);
+        object["Authorization"] = "Bearer " + accessToken;
     }
 }
 
@@ -78,7 +79,7 @@ export const setOAuthToObject = async function (object: any, name: string, scope
         const localVarAccessTokenValue = typeof configuration.accessToken === 'function'
             ? await configuration.accessToken(name, scopes)
             : await configuration.accessToken;
-        object["Authorization"] = configuration.getBearerToken(localVarAccessTokenValue);
+        object["Authorization"] = "Bearer " + localVarAccessTokenValue;
     }
 }
 

package/configuration.ts

@@ -74,6 +74,14 @@ export class Configuration {
      */
     formDataCtor?: new () => any;
 
+    /**
+     * parameter for automatically refreshing access token for oauth2 security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    refreshToken?: string;
+
     constructor(param: ConfigurationParameters = {}) {
         this.apiKey = param.apiKey;
         this.username = param.username;
@@ -98,13 +106,4 @@ export class Configuration {
         const jsonMime: RegExp = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
         return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
     }
-
-    /**
-     * Returns "Bearer" token.
-     * @param token - access token.
-     * @return Bearer token.
-     */
-    public getBearerToken(token?: string): string {
-        return ('' + token).startsWith("Bearer") ? token : "Bearer " + token;
-    }
 }