@emilgroup/translation-sdk 1.1.0 → 1.1.1-beta.11

package/api.ts

@@ -15,17 +15,15 @@
 
 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,20 +14,13 @@
 
 
 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 const BASE_PATH = "https://apiv2.emil.de".replace(/\/+$/, "");
 /**
  *
  * @export
@@ -41,13 +34,25 @@ export const COLLECTION_FORMATS = {
 
 export interface LoginClass {
     accessToken: string;
-    permissions: Array<string>;
+    permissions: string;
+}
+
+export interface SwitchWorkspaceRequest {
+    username: string;
+    targetWorkspace: string;
+}
+
+export interface SwitchWorkspaceResponseClass {
+    accessToken: string;
+    permissions: 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
@@ -67,7 +72,14 @@ export interface RequestArgs {
     options: AxiosRequestConfig;
 }
 
+interface TokenData {
+    accessToken?: string;
+    username?: string;
+    permissions?: string;
+}
+
 const NETWORK_ERROR_MESSAGE = "Network Error";
+const TOKEN_DATA = 'APP_TOKEN';
 
 /**
  *
@@ -75,80 +87,54 @@ const NETWORK_ERROR_MESSAGE = "Network Error";
  * @class BaseAPI
  */
 export class BaseAPI {
-    protected configuration: Configuration;
-    private username?: string;
-    private password?: string;
+    protected configuration: Configuration | undefined;
+    private tokenData?: TokenData;
+
+    constructor(configuration?: Configuration,
+        protected basePath: string = BASE_PATH, 
+        protected axios: AxiosInstance = globalAxios) {
+        
+        this.loadTokenData();
 
-    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);
     }
 
-    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.`);
-        }
+    selectEnvironment(env: Environment) {
+        this.selectBasePath(env);
     }
 
-    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) : '';
-            }
-        });
+    selectBasePath(path: string) {
+        this.configuration.basePath = path;
     }
 
-    private readEnvVariables(): boolean {
-        if (process.env.EMIL_USERNAME) {
-            this.username = process.env.EMIL_USERNAME;
-            this.password = process.env.EMIL_PASSWORD || '';
-
-            return true;
+    getPermissions(): Array<string> {
+        if (!this.tokenData?.permissions) {
+            return [];
         }
 
-        return false;
-    }
-    
-    selectEnvironment(env: Environment) {
-        this.configuration.basePath = env;
+        return this.tokenData.permissions.split(',');
     }
 
-    async authorize(username: string, password: string): Promise<void> {
+    async authorize(username: string, password: string, targetWorkspace?: string): Promise<void> {
         const options: AxiosRequestConfig = {
             method: 'POST',
             url: `${this.configuration.basePath}/authservice/v1/login`,
@@ -162,50 +148,104 @@ export class BaseAPI {
 
         const response = await globalAxios.request<LoginClass>(options);
 
-        const { data: { accessToken } } = response;
+        const { data: { accessToken, permissions } } = response;
+
         this.configuration.username = username;
         this.configuration.accessToken = `Bearer ${accessToken}`;
+        this.tokenData.username = username;
+        this.tokenData.accessToken = accessToken;
+        this.tokenData.permissions = permissions;
 
-        const refreshToken = this.extractRefreshToken(response)
-        this.configuration.refreshToken = refreshToken;
+        // 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
+            });
+        }
+
+        this.storeTokenData({
+            ...this.tokenData
+        });
     }
 
-    async refreshTokenInternal(): Promise<string> {
-        const { username, refreshToken } = this.configuration;
+    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;
         
+        this.configuration.accessToken = `Bearer ${accessToken}`;
+        this.tokenData.accessToken = accessToken;
+        this.tokenData.permissions = permissions;
+
+        this.storeTokenData({
+            ...this.tokenData
+        });
+    }
 
-        if (!username || !refreshToken) {
-            return '';
+    async refreshTokenInternal(): Promise<LoginClass> {
+        const { username } = this.configuration;
+
+        if (!username) {
+            throw new Error('Failed to refresh token.');
         }
 
+        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 { data: { accessToken } } = await globalAxios.request<LoginClass>(options);
-
-        return accessToken;
+        const response = await refreshTokenAxios.request<LoginClass>(options);
+        return response.data;
     }
 
-    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]};`;
+    private storeTokenData(tokenData?: TokenData) {
+        if (typeof window !== 'undefined') {
+            defaultStorage().set<TokenData>(TOKEN_DATA, tokenData);
         }
+    }
 
-        return '';
+    public loadTokenData() {
+        if (typeof window !== 'undefined') {
+            this.tokenData = defaultStorage().get<TokenData>(TOKEN_DATA) || {};
+        } else {
+            this.tokenData = {};
+        }
     }
 
-    getConfiguration(): Configuration {
-        return this.configuration;
+    public cleanTokenData() {
+        this.storeTokenData(null);
     }
 
     private attachInterceptor(axios: AxiosInstance) {
@@ -215,19 +255,26 @@ export class BaseAPI {
             },
             async (err) => {
                 let originalConfig = err.config;
-                if (err.response) {
+                if (err.response && !(err.response instanceof XMLHttpRequest)) { // sometimes buggy and is of type request
                     // Access Token was expired
-                    if (err.response.status === 401 && !originalConfig._retry) {
+                    if ((err.response.status === 401 || err.response.status === 403)
+                        && !originalConfig._retry) {
                         originalConfig._retry = true;
                         try {
-                            const tokenString = await this.refreshTokenInternal();
+                            const { accessToken: tokenString, permissions } = await this.refreshTokenInternal();
                             const accessToken = `Bearer ${tokenString}`;
+                            this.tokenData.permissions = permissions;
+
+                            delete originalConfig.headers['Authorization']
 
-                            originalConfig.headers['Authorization'] = `Bearer ${accessToken}`
+                            originalConfig.headers['Authorization'] = accessToken;
 
                             this.configuration.accessToken = accessToken;
+                            this.tokenData.accessToken = tokenString;
 
-                            return axios.request(originalConfig);
+                            this.storeTokenData(this.tokenData);
+
+                            return axios(originalConfig);
                         } catch (_error) {
                             if (_error.response && _error.response.data) {
                                 return Promise.reject(_error.response.data);
@@ -235,23 +282,23 @@ export class BaseAPI {
                             return Promise.reject(_error);
                         }
                     }
-                    if (err.response.status === 403 && err.response.data) {
-                        return Promise.reject(err.response.data);
-                    }
-                } else if(err.message === NETWORK_ERROR_MESSAGE 
-                    && err.isAxiosError
+                } else if (err.message === NETWORK_ERROR_MESSAGE
                     && originalConfig.headers.hasOwnProperty('Authorization')
                     && _retry_count < 4
-                ){ 
+                ) {
                     _retry_count++;
                     try {
-                        const tokenString = await this.refreshTokenInternal();
+                        const { accessToken: tokenString, permissions } = 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,
@@ -261,7 +308,7 @@ export class BaseAPI {
                             return Promise.reject(_error.response.data);
                         }
                         return Promise.reject(_error);
-                    }                    
+                    }
                 }
                 return Promise.reject(err);
             }
@@ -276,7 +323,7 @@ export class BaseAPI {
  * @extends {Error}
  */
 export class RequiredError extends Error {
-    name: "RequiredError" = "RequiredError";
+    override name: "RequiredError" = "RequiredError";
     constructor(public field: string, msg?: string) {
         super(msg);
     }

package/common.ts

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

package/configuration.ts

@@ -74,14 +74,6 @@ 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;
@@ -106,4 +98,13 @@ 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;
+    }
 }

package/dist/api/default-api.d.ts

@@ -0,0 +1,70 @@
+/**
+ * EMIL TranslationService
+ * The EMIL TranslationService API description
+ *
+ * The version of the OpenAPI document: 1.0
+ * Contact: kontakt@emil.de
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { AxiosPromise, AxiosInstance, AxiosRequestConfig } from 'axios';
+import { Configuration } from '../configuration';
+import { RequestArgs, BaseAPI } from '../base';
+import { InlineResponse200 } from '../models';
+/**
+ * DefaultApi - axios parameter creator
+ * @export
+ */
+export declare const DefaultApiAxiosParamCreator: (configuration?: Configuration) => {
+    /**
+     * Returns the health status of the translation service.        This endpoint is used to monitor the operational status of the translation service.        It typically returns a simple status indicator, such as \'UP\' or \'OK\', confirming that the service is operational and available.
+     * @summary Health Check
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    check: (options?: AxiosRequestConfig) => Promise<RequestArgs>;
+};
+/**
+ * DefaultApi - functional programming interface
+ * @export
+ */
+export declare const DefaultApiFp: (configuration?: Configuration) => {
+    /**
+     * Returns the health status of the translation service.        This endpoint is used to monitor the operational status of the translation service.        It typically returns a simple status indicator, such as \'UP\' or \'OK\', confirming that the service is operational and available.
+     * @summary Health Check
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    check(options?: AxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<InlineResponse200>>;
+};
+/**
+ * DefaultApi - factory interface
+ * @export
+ */
+export declare const DefaultApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
+    /**
+     * Returns the health status of the translation service.        This endpoint is used to monitor the operational status of the translation service.        It typically returns a simple status indicator, such as \'UP\' or \'OK\', confirming that the service is operational and available.
+     * @summary Health Check
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    check(options?: any): AxiosPromise<InlineResponse200>;
+};
+/**
+ * DefaultApi - object-oriented interface
+ * @export
+ * @class DefaultApi
+ * @extends {BaseAPI}
+ */
+export declare class DefaultApi extends BaseAPI {
+    /**
+     * Returns the health status of the translation service.        This endpoint is used to monitor the operational status of the translation service.        It typically returns a simple status indicator, such as \'UP\' or \'OK\', confirming that the service is operational and available.
+     * @summary Health Check
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof DefaultApi
+     */
+    check(options?: AxiosRequestConfig): Promise<import("axios").AxiosResponse<InlineResponse200, any, {}>>;
+}