@sisense/sdk-rest-client 1.14.0 → 1.15.1

package/dist/authenticator.d.ts

@@ -1,2 +1,12 @@
 import { Authenticator } from './interfaces.js';
-export declare function getAuthenticator(url: string, username: string | undefined, password: string | undefined, token: string | undefined, wat: string | undefined, ssoEnabled: boolean | undefined, enableSilentPreAuth?: boolean): Authenticator | null;
+declare type AuthenticatorConfig = {
+    url: string;
+    username?: string;
+    password?: string;
+    token?: string;
+    wat?: string;
+    ssoEnabled?: boolean;
+    enableSilentPreAuth?: boolean;
+};
+export declare function getAuthenticator({ url, username, password, token, wat, ssoEnabled, enableSilentPreAuth, }: AuthenticatorConfig): Authenticator | null;
+export {};

package/dist/authenticator.js

@@ -2,7 +2,7 @@ import { PasswordAuthenticator } from './password-authenticator.js';
 import { BearerAuthenticator } from './bearer-authenticator.js';
 import { WatAuthenticator } from './wat-authenticator.js';
 import { SsoAuthenticator } from './sso-authenticator.js';
-export function getAuthenticator(url, username, password, token, wat, ssoEnabled, enableSilentPreAuth = false) {
+export function getAuthenticator({ url, username, password, token, wat, ssoEnabled = false, enableSilentPreAuth = false, }) {
     // sso overrides all other auth methods
     if (ssoEnabled) {
         return new SsoAuthenticator(url, enableSilentPreAuth);

package/dist/base-authenticator.d.ts

@@ -0,0 +1,16 @@
+import { Authenticator } from './interfaces.js';
+export declare class BaseAuthenticator implements Authenticator {
+    readonly type: Authenticator['type'];
+    private _valid;
+    protected _authenticating: boolean;
+    protected _tried: boolean;
+    protected _resolve: (value: boolean) => void;
+    protected readonly _result: Promise<boolean>;
+    protected constructor(type: Authenticator['type']);
+    isValid(): boolean;
+    invalidate(): void;
+    authenticate(): Promise<boolean>;
+    isAuthenticating(): boolean;
+    authenticated(): Promise<boolean>;
+    applyHeader(headers: HeadersInit): void;
+}

package/dist/base-authenticator.js

@@ -0,0 +1,30 @@
+export class BaseAuthenticator {
+    constructor(type) {
+        this._valid = true;
+        this._authenticating = false;
+        this._tried = false;
+        this._result = new Promise((resolve) => {
+            this._resolve = resolve;
+        });
+        this.type = type;
+    }
+    isValid() {
+        return this._valid;
+    }
+    invalidate() {
+        this._valid = false;
+    }
+    authenticate() {
+        return this._result;
+    }
+    isAuthenticating() {
+        return this._authenticating;
+    }
+    authenticated() {
+        return this._result;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+    applyHeader(headers) {
+        // Do nothing
+    }
+}

package/dist/bearer-authenticator.d.ts

@@ -1,15 +1,11 @@
 import { Authenticator } from './interfaces.js';
-export declare class BearerAuthenticator implements Authenticator {
-    readonly type = "bearer";
+import { BaseAuthenticator } from './base-authenticator.js';
+export declare class BearerAuthenticator extends BaseAuthenticator {
     readonly bearer: string;
-    readonly url: string;
-    private _valid;
     constructor(url: string, bearer: string);
-    isValid(): boolean;
-    invalidate(): void;
-    isAuthenticating(): boolean;
     applyHeader(headers: HeadersInit): void;
     authenticate(): Promise<boolean>;
+    authenticated(): Promise<boolean>;
 }
 /**
  * Checks if an authenticator is a BearerAuthenticator.

package/dist/bearer-authenticator.js

@@ -1,40 +1,21 @@
-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());
-    });
-};
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+import { BaseAuthenticator } from './base-authenticator.js';
 import { appendHeaders } from './helpers.js';
-export class BearerAuthenticator {
+export class BearerAuthenticator extends BaseAuthenticator {
     constructor(url, bearer) {
-        this.type = 'bearer';
-        this._valid = true;
+        super('bearer');
         this.bearer = bearer;
-        this.url = url;
-    }
-    isValid() {
-        return this._valid;
-    }
-    invalidate() {
-        this._valid = false;
-    }
-    isAuthenticating() {
-        return false;
+        this._resolve(true);
     }
     applyHeader(headers) {
         const authHeader = 'Bearer ' + this.bearer;
         appendHeaders(headers, { Authorization: authHeader });
     }
     authenticate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: implement authentication test
-            return Promise.resolve(true);
-        });
+        // TODO: implement authentication test
+        return this._result;
+    }
+    authenticated() {
+        return this._result;
     }
 }
 /**

package/dist/helpers.js

@@ -1,12 +1,13 @@
 export const appendHeaders = (existingHeaders, additionalHeaders) => {
     for (const [headerName, headerValue] of Object.entries(additionalHeaders)) {
-        if (existingHeaders instanceof Headers) {
-            existingHeaders.set(headerName, headerValue);
-        }
-        else if (Array.isArray(existingHeaders)) {
+        if (Array.isArray(existingHeaders)) {
             existingHeaders.push([headerName, headerValue]);
         }
+        else if (typeof existingHeaders.set === 'function') {
+            existingHeaders.set(headerName, headerValue);
+        }
         else {
+            // eslint-disable-next-line security/detect-object-injection
             existingHeaders[headerName] = headerValue;
         }
     }

package/dist/http-client.js

@@ -9,9 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import fetchIntercept from 'fetch-intercept';
 import { getResponseInterceptor, errorInterceptor } from './interceptors.js';
-import { SsoAuthenticator } from './sso-authenticator.js';
+import { isSsoAuthenticator } from './sso-authenticator.js';
 import { addQueryParamsToUrl } from './helpers.js';
-const AUTH_WAIT_MS = 10;
 export class HttpClient {
     constructor(url, auth, env) {
         if (!url.endsWith('/')) {
@@ -26,27 +25,15 @@ export class HttpClient {
         });
     }
     login() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.auth.authenticate();
-        });
+        return this.auth.authenticate();
     }
     call(url, config, requestConfig) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.auth.isAuthenticating()) {
-                return new Promise((res) => {
-                    const retry = () => {
-                        // wait if still authenticating
-                        if (this.auth.isAuthenticating()) {
-                            setTimeout(retry, AUTH_WAIT_MS);
-                            return;
-                        }
-                        void this.call(url, config, requestConfig).then((r) => res(r));
-                    };
-                    retry();
-                });
+                yield this.auth.authenticated();
             }
             config.headers = config.headers || {};
-            if (this.auth instanceof SsoAuthenticator) {
+            if (isSsoAuthenticator(this.auth)) {
                 // allows cookies to be sent
                 config.credentials = 'include';
             }

package/dist/interceptors.js

@@ -1,7 +1,7 @@
-import { BearerAuthenticator } from './bearer-authenticator.js';
-import { WatAuthenticator } from './wat-authenticator.js';
-import { PasswordAuthenticator } from './password-authenticator.js';
-import { SsoAuthenticator } from './sso-authenticator.js';
+import { isBearerAuthenticator } from './bearer-authenticator.js';
+import { isWatAuthenticator } from './wat-authenticator.js';
+import { isPasswordAuthenticator } from './password-authenticator.js';
+import { isSsoAuthenticator } from './sso-authenticator.js';
 import { TranslatableError } from './translation/translatable-error.js';
 function handleErrorResponse(response) {
     if (!response.ok) {
@@ -16,13 +16,13 @@ function handleErrorResponse(response) {
 function handleUnauthorizedResponse(response, auth) {
     auth.invalidate();
     // skip login redirect for token auth
-    if (auth instanceof PasswordAuthenticator) {
+    if (isPasswordAuthenticator(auth)) {
         throw new TranslatableError('errors.passwordAuthFailed');
     }
-    if (auth instanceof BearerAuthenticator || auth instanceof WatAuthenticator) {
+    if (isBearerAuthenticator(auth) || isWatAuthenticator(auth)) {
         throw new TranslatableError('errors.tokenAuthFailed');
     }
-    if (auth instanceof SsoAuthenticator && !auth.isAuthenticating()) {
+    if (isSsoAuthenticator(auth) && !auth.isAuthenticating()) {
         // try to reauthenticate
         void auth.authenticate();
     }

package/dist/interfaces.d.ts

@@ -1,8 +1,9 @@
 export interface Authenticator {
-    readonly type: 'password' | 'bearer' | 'wat' | 'sso';
+    readonly type: 'password' | 'bearer' | 'wat' | 'sso' | 'base';
     isValid: () => boolean;
     invalidate: () => void;
     authenticate: () => Promise<boolean>;
     isAuthenticating: () => boolean;
+    authenticated: () => Promise<boolean>;
     applyHeader: (headers: HeadersInit) => void;
 }

package/dist/password-authenticator.d.ts

@@ -1,19 +1,13 @@
 /// <reference lib="dom" />
 import { Authenticator } from './interfaces.js';
-export declare class PasswordAuthenticator implements Authenticator {
-    readonly type = "password";
+import { BaseAuthenticator } from './base-authenticator.js';
+export declare class PasswordAuthenticator extends BaseAuthenticator {
+    private readonly url;
+    private readonly body;
     private _authheader;
-    readonly user: string;
-    readonly pass: string;
-    readonly url: string;
-    private _authenticating;
-    private _valid;
     constructor(url: string, user: string, pass: string);
-    isValid(): boolean;
-    invalidate(): void;
-    isAuthenticating(): boolean;
-    applyHeader(headers: HeadersInit): void;
     authenticate(): Promise<boolean>;
+    applyHeader(headers: HeadersInit): void;
 }
 /**
  * Checks if an authenticator is a PasswordAuthenticator.

package/dist/password-authenticator.js

@@ -7,58 +7,49 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-/* eslint-disable no-underscore-dangle */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/restrict-plus-operands */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/// <reference lib="dom" />
+import { BaseAuthenticator } from './base-authenticator.js';
 import { appendHeaders } from './helpers.js';
-export class PasswordAuthenticator {
+export class PasswordAuthenticator extends BaseAuthenticator {
     constructor(url, user, pass) {
-        this.type = 'password';
-        this._authenticating = false;
-        this._valid = true;
-        this._authheader = undefined;
-        this.url = url;
-        this.user = user;
-        this.pass = pass;
-    }
-    isValid() {
-        return this._valid;
-    }
-    invalidate() {
-        this._valid = false;
-    }
-    isAuthenticating() {
-        return this._authenticating;
-    }
-    applyHeader(headers) {
-        const authHeader = 'Bearer ' + this._authheader;
-        appendHeaders(headers, { Authorization: authHeader });
+        super('password');
+        this._authheader = '';
+        this.url = `${url}${!url.endsWith('/') ? '/' : ''}api/v1/authentication/login`;
+        const username = encodeURIComponent(user);
+        const password = encodeURIComponent(pass);
+        this.body = `username=${username}&password=${password}`;
     }
     authenticate() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._authenticating = true;
-            const url = `${this.url}${!this.url.endsWith('/') ? '/' : ''}api/v1/authentication/login`;
-            const username = encodeURIComponent(this.user);
-            const password = encodeURIComponent(this.pass);
-            yield fetch(url, {
-                method: 'POST',
-                headers: {
-                    accept: 'application/json',
-                    'Content-Type': 'application/x-www-form-urlencoded',
-                },
-                body: `username=${username}&password=${password}`,
-            })
-                .then((response) => response.json())
-                .then((responseJson) => {
-                this._authheader = responseJson.access_token;
+            if (this._tried) {
+                return this._result;
+            }
+            this._tried = true;
+            try {
+                this._authenticating = true;
+                const response = yield fetch(this.url, {
+                    method: 'POST',
+                    headers: {
+                        accept: 'application/json',
+                        'Content-Type': 'application/x-www-form-urlencoded',
+                    },
+                    body: this.body,
+                });
+                if (response.ok) {
+                    const json = yield response.json();
+                    this._authheader = json.access_token;
+                }
+            }
+            finally {
+                this._resolve(!!this._authheader);
                 this._authenticating = false;
-            });
-            return !!this._authheader;
+            }
+            return this._result;
         });
     }
+    applyHeader(headers) {
+        const authHeader = 'Bearer ' + this._authheader;
+        appendHeaders(headers, { Authorization: authHeader });
+    }
 }
 /**
  * Checks if an authenticator is a PasswordAuthenticator.

package/dist/sso-authenticator.d.ts

@@ -1,19 +1,13 @@
 /// <reference lib="dom" />
 import { Authenticator } from './interfaces.js';
-export declare class SsoAuthenticator implements Authenticator {
-    readonly type = "sso";
+import { BaseAuthenticator } from './base-authenticator.js';
+export declare class SsoAuthenticator extends BaseAuthenticator {
     readonly url: string;
     private _enableSilentPreAuth;
-    private _valid;
-    private _authenticating;
     constructor(url: string, enableSilentPreAuth?: boolean);
-    isValid(): boolean;
-    invalidate(): void;
-    isAuthenticating(): boolean;
-    applyHeader(headers: HeadersInit): HeadersInit;
+    authenticate(silent?: boolean): Promise<boolean>;
     private authenticateSilent;
     private checkAuthentication;
-    authenticate(silent?: boolean): Promise<boolean>;
 }
 /**
  * Checks if the authenticator is SSO authenticator

package/dist/sso-authenticator.js

@@ -8,26 +8,40 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { BaseAuthenticator } from './base-authenticator.js';
 import { TranslatableError } from './translation/translatable-error.js';
-export class SsoAuthenticator {
+export class SsoAuthenticator extends BaseAuthenticator {
     constructor(url, enableSilentPreAuth = false) {
-        this.type = 'sso';
-        this._valid = true;
-        this._authenticating = false;
+        super('sso');
         this.url = url;
         this._enableSilentPreAuth = enableSilentPreAuth;
     }
-    isValid() {
-        return this._valid;
-    }
-    invalidate() {
-        this._valid = false;
-    }
-    isAuthenticating() {
-        return this._authenticating;
-    }
-    applyHeader(headers) {
-        return headers;
+    authenticate(silent = true) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this._authenticating = true;
+                const { isAuthenticated, loginUrl } = yield this.checkAuthentication();
+                if (isAuthenticated) {
+                    this._resolve(true);
+                    return yield this._result;
+                }
+                if (this._enableSilentPreAuth && silent) {
+                    yield this.authenticateSilent(loginUrl);
+                    const { isAuthenticated } = yield this.checkAuthentication();
+                    if (isAuthenticated) {
+                        this._resolve(true);
+                        return yield this._result;
+                    }
+                }
+                (_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.replace(loginUrl);
+            }
+            finally {
+                this._resolve(false);
+                this._authenticating = false;
+            }
+            return this._result;
+        });
     }
     authenticateSilent(loginUrl) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -65,26 +79,6 @@ export class SsoAuthenticator {
             };
         });
     }
-    authenticate(silent = true) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            this._authenticating = true;
-            const { isAuthenticated, loginUrl } = yield this.checkAuthentication();
-            if (!isAuthenticated) {
-                if (this._enableSilentPreAuth && silent) {
-                    yield this.authenticateSilent(loginUrl);
-                    return this.authenticate(false);
-                }
-                (_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.assign(loginUrl);
-                return false;
-            }
-            else {
-                // no authentication needed, indicate success
-                this._authenticating = false;
-                return true;
-            }
-        });
-    }
 }
 /**
  * Checks if the authenticator is SSO authenticator

package/dist/wat-authenticator.d.ts

@@ -1,19 +1,14 @@
 /// <reference lib="dom" />
 import { Authenticator } from './interfaces.js';
-export declare class WatAuthenticator implements Authenticator {
-    readonly type = "wat";
+import { BaseAuthenticator } from './base-authenticator.js';
+export declare class WatAuthenticator extends BaseAuthenticator {
     private _initialiser;
     private _webSessionToken;
-    readonly wat: string;
-    readonly url: string;
-    private _authenticating;
-    private _valid;
+    private readonly url;
+    private readonly body;
     constructor(url: string, wat: string);
-    isValid(): boolean;
-    invalidate(): void;
-    isAuthenticating(): boolean;
-    applyHeader(headers: HeadersInit): void;
     authenticate(): Promise<boolean>;
+    applyHeader(headers: HeadersInit): void;
 }
 /**
  * Checks if an authenticator is a WatAuthenticator.

package/dist/wat-authenticator.js

@@ -8,65 +8,54 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-/* eslint-disable no-underscore-dangle */
+import { BaseAuthenticator } from './base-authenticator.js';
 import { appendHeaders } from './helpers.js';
-export class WatAuthenticator {
+export class WatAuthenticator extends BaseAuthenticator {
     constructor(url, wat) {
-        this.type = 'wat';
-        this._authenticating = false;
-        this._valid = true;
-        this._initialiser = undefined;
-        this.url = url;
-        this.wat = wat;
-    }
-    isValid() {
-        return this._valid;
-    }
-    invalidate() {
-        this._valid = false;
-    }
-    isAuthenticating() {
-        return this._authenticating;
-    }
-    applyHeader(headers) {
-        if (!!this._webSessionToken && !!this._initialiser) {
-            const authHeader = this._webSessionToken;
-            const initialiserHeader = this._initialiser;
-            appendHeaders(headers, { Authorization: authHeader, Initialiser: initialiserHeader });
-        }
+        super('wat');
+        this.url = `${url}${!url.endsWith('/') ? '/' : ''}api/v1/wat/sessionToken`;
+        this.body = `{"webAccessToken": "${wat}"}`;
     }
     authenticate() {
         return __awaiter(this, void 0, void 0, function* () {
-            this._authenticating = true;
-            // call API to generate web session token
-            const url = `${this.url}${!this.url.endsWith('/') ? '/' : ''}api/v1/wat/sessionToken`;
+            if (this._tried) {
+                return this._result;
+            }
+            this._tried = true;
             try {
-                const response = yield fetch(url, {
+                this._authenticating = true;
+                const response = yield fetch(this.url, {
                     method: 'POST',
                     headers: {
                         accept: 'application/json',
                         'Content-Type': 'application/json',
                     },
-                    body: `{"webAccessToken": "${this.wat}"}`,
+                    body: this.body,
                 });
                 if (response.ok) {
-                    const responseJson = (yield response.json());
+                    const responseJson = yield response.json();
                     this._initialiser = responseJson.initialiser;
                     this._webSessionToken = responseJson.webSessionToken;
-                    this._authenticating = false;
-                }
-                else {
-                    return false;
+                    this._resolve(true);
                 }
             }
             catch (e) {
-                this._initialiser = undefined;
+                // empty catch block
+            }
+            finally {
+                this._resolve(false);
                 this._authenticating = false;
-                return false;
             }
-            return true;
+            return this._result;
         });
     }
+    applyHeader(headers) {
+        if (!!this._webSessionToken && !!this._initialiser) {
+            const authHeader = this._webSessionToken;
+            const initialiserHeader = this._initialiser;
+            appendHeaders(headers, { Authorization: authHeader, Initialiser: initialiserHeader });
+        }
+    }
 }
 /**
  * Checks if an authenticator is a WatAuthenticator.

package/package.json

@@ -11,7 +11,7 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.14.0",
+  "version": "1.15.1",
   "type": "module",
   "exports": "./dist/index.js",
   "main": "./dist/index.js",
@@ -20,7 +20,7 @@
   "author": "Sisense",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@sisense/sdk-common": "^1.14.0",
+    "@sisense/sdk-common": "^1.15.1",
     "fetch-intercept": "^2.4.0"
   },
   "scripts": {