attlaz-client 1.18.3 → 1.18.5

package/dist/Client.d.ts

@@ -31,12 +31,14 @@ import { SearchEndpoint } from './Service/SearchEndpoint.js';
 import { UserActionEndpoint } from './Service/UserActionEndpoint.js';
 import { AccessTokenEndpoint } from './Service/AccessTokenEndpoint.js';
 export declare class Client {
-    private endpoints;
+    private readonly endpoints;
     private httpClient;
-    private Store;
+    private readonly Store;
     private apiEndpoint;
     private parseConfig;
-    constructor(token?: string | null, config?: Record<string, unknown>);
+    constructor(token?: string | null, config?: {
+        apiEndpoint: string | undefined;
+    });
     setClientCredentials(clientId: string, clientSecret?: string): void;
     getHttpClient(): OAuthClient;
     authenticate(): Promise<boolean>;

package/dist/Client.js

@@ -71,7 +71,7 @@ export class Client {
         // TODO: go over other records in config and warn if any unknown ones
         return config;
     }
-    constructor(token = null, config = {}) {
+    constructor(token = null, config = { apiEndpoint: undefined }) {
         const parsedConfig = this.parseConfig(config);
         if (parsedConfig.apiEndpoint !== undefined) {
             this.apiEndpoint = parsedConfig.apiEndpoint;
@@ -95,10 +95,10 @@ export class Client {
     }
     async authenticate(username = null, password = null) {
         if (username === null || password === null) {
-            return this.httpClient.authenticate();
+            return await this.httpClient.authenticate();
         }
         // TODO: this is only possible when clientId and clientSecret are defined
-        return this.httpClient.authenticate(username, password);
+        return await this.httpClient.authenticate(username, password);
     }
     isAuthenticated() {
         return this.httpClient.isAuthenticated();
@@ -208,18 +208,18 @@ export class Client {
     getFirewallEndpoint() {
         return this.getEndpoint('firewall', this.Store.FirewallEndpoint);
     }
-    getEndpoint(key, className) {
+    getEndpoint(key, ClassName) {
         // const classNameString: string = className.name;
         if (!this.endpoints.has(key)) {
             // if (this.Store[classNameString] === undefined || this.Store[classNameString] === null) {
             //     throw new Error(`Class type of \'${classNameString}\' is not in the store`);
             // }
             try {
-                const endpoint = new className(this.httpClient);
+                const endpoint = new ClassName(this.httpClient);
                 this.endpoints.set(key, endpoint);
             }
-            catch (e) {
-                throw new Error('Unable to initialize ' + key + ' endpoint (' + e.message + ')');
+            catch (error) {
+                throw new Error('Unable to initialize ' + key + ' endpoint (' + error.message + ')');
             }
         }
         return this.endpoints.get(key);

package/dist/Http/ClientError.d.ts

@@ -1,8 +1,12 @@
+import { AxiosError } from 'axios';
 export declare class ClientError extends Error {
-    code: number | null;
-    name: string;
+    httpErrorCode: number | null;
+    type: string;
+    code: string;
+    message: string;
+    param?: string;
     stack?: string;
-    constructor(name: string, code?: number | null);
-    static fromError(error: Error | any): ClientError;
+    constructor(code: string, httpErrorCode?: number | null);
+    static fromError(error: Error | AxiosError): ClientError;
     static byStatus(statusCode: number, statusText: string): ClientError | null;
 }

package/dist/Http/ClientError.js

@@ -1,51 +1,73 @@
+import { AxiosError } from 'axios';
 import { HttpClient } from './HttpClient.js';
 export class ClientError extends Error {
+    httpErrorCode = null;
+    type;
     code;
-    name;
+    message;
+    param = undefined;
     stack = undefined;
-    constructor(name, code = null) {
-        super(name);
-        this.name = name;
+    constructor(code, httpErrorCode = null) {
+        super(code);
         this.code = code;
+        this.httpErrorCode = httpErrorCode;
     }
     static fromError(error) {
-        if (error.body !== undefined && error.body !== null && error.body.error !== undefined && error.body.error !== null) {
-            error = error.body.error;
-        }
-        let message = error;
-        if (error.message !== undefined && error.message !== null) {
-            message = error.message;
+        let clientError = new ClientError('Unknown error', HttpClient.HTTP_INTERNAL_SERVER_ERROR);
+        if (error instanceof AxiosError) {
+            if (error.status !== undefined) {
+                clientError.httpErrorCode = error.status;
+            }
+            if (error.response !== undefined) {
+                const errorData = error.response.data;
+                clientError.type = errorData.type;
+                clientError.code = errorData.code;
+                clientError.message = errorData.message;
+                clientError.param = errorData.param;
+            }
+            else {
+                console.error('Unable to parse AxiosError response', { error });
+            }
+            return clientError;
         }
-        let clientError = new ClientError(message);
+        // if (error.body !== undefined && error.body !== null && error.body.error !== undefined && error.body.error !== null) {
+        //     error = error.body.error;
+        // }
+        // let message: string = error;
+        // if (error.message !== undefined && error.message !== null) {
+        //     message = error.message;
+        // }
+        //
         // console.error(error);
-        if (error.status !== null && error.status !== undefined) {
-            const statusCode = error.status;
-            const { body } = error;
+        const xError = error;
+        if (xError.status !== null && xError.status !== undefined) {
+            const statusCode = xError.status;
+            const { body } = xError;
             const clientErrorByStatus = this.byStatus(statusCode, body);
             if (clientErrorByStatus !== null) {
                 clientError = clientErrorByStatus;
             }
         }
-        else if (error.code !== null && error.code !== undefined) {
-            switch (error.code) {
+        else if (xError.code !== null && xError.code !== undefined) {
+            switch (xError.code) {
                 case 'EUNAVAILABLE':
-                    clientError.code = HttpClient.HTTP_UNAVAILABLE;
+                    clientError.httpErrorCode = HttpClient.HTTP_UNAVAILABLE;
                     break;
                 case 'EAUTH':
                 case 401:
-                    clientError.code = HttpClient.HTTP_UNAUTHORIZED;
+                    clientError.httpErrorCode = HttpClient.HTTP_UNAUTHORIZED;
                     break;
                 case 'ESTATUS':
                     if (error.message === 'HTTP status 503') {
-                        clientError.code = HttpClient.HTTP_UNAVAILABLE;
+                        clientError.httpErrorCode = HttpClient.HTTP_UNAVAILABLE;
                     }
                     break;
                 case 500:
-                    clientError.code = HttpClient.HTTP_INTERNAL_SERVER_ERROR;
+                    clientError.httpErrorCode = HttpClient.HTTP_INTERNAL_SERVER_ERROR;
                     break;
                 default:
-                    console.warn('[Client error] Error code `' + error.code + '` not recognised');
-                    clientError.code = error.code;
+                    console.warn('[Client error] Error code `' + xError.code + '` not recognised');
+                    clientError.httpErrorCode = HttpClient.HTTP_INTERNAL_SERVER_ERROR;
             }
         }
         clientError.name = error.name;
@@ -83,6 +105,5 @@ export class ClientError extends Error {
                 console.error('Unknown status code "' + statusCode + '"', { code: statusCode, text: statusText });
                 return new ClientError('Status code ' + statusCode + ': ' + statusText, statusCode);
         }
-        return null;
     }
 }

package/dist/Http/HttpClient.js

@@ -1,4 +1,4 @@
-import axios, { AxiosError } from 'axios';
+import axios from 'axios';
 import { HttpClientResponse } from './HttpClientResponse.js';
 import { ClientError } from './ClientError.js';
 export class HttpClient {
@@ -14,13 +14,15 @@ export class HttpClient {
     static HTTP_TIMEOUT = 504;
     static async request(request) {
         const response = await HttpClient.axiosRequest(request);
-        const error = ClientError.byStatus(response.status, response.statusText);
-        if (error !== null && error !== undefined) {
-            if (response.body !== null && response.body !== undefined && response.body.error !== null && response.body.error !== undefined && response.body.error.message !== null && response.body.error.message !== undefined) {
-                error.message = response.body.error.message;
-            }
-            throw error;
-        }
+        // const error: ClientError | null = ClientError.byStatus(response.status, response.statusText);
+        // if (error !== null && error !== undefined) {
+        //     if (response.body !== null && response.body !== undefined && response.body.error !== null && response.body.error !== undefined && response.body.error.message !== null && response.body.error.message !== undefined
+        //     ) {
+        //         error.message = response.body.error.message;
+        //     }
+        //
+        //     throw error;
+        // }
         return response;
     }
     static async axiosRequest(request) {
@@ -45,19 +47,17 @@ export class HttpClient {
             httpResponse.body = await rawResponse.data;
             return httpResponse;
         }
-        catch (e) {
-            if (e instanceof AxiosError) {
-                const status = e.status === undefined ? 500 : e.status;
-                const statusCode = e.code === undefined ? 'Error' : e.code;
-                const response = new HttpClientResponse(status, statusCode);
-                if (e.response !== undefined) {
-                    response.body = e.response.data;
-                }
-                return response;
-            }
-            console.error('Unable to perform request', { error: e });
-            const response = new HttpClientResponse(500, '');
-            return response;
+        catch (requestError) {
+            // if (requestError instanceof AxiosError) {
+            //     const status: number = requestError.status === undefined ? 500 : requestError.status;
+            //     const statusCode: string = requestError.code === undefined ? 'Error' : requestError.code;
+            //
+            //     const response: HttpClientResponse = new HttpClientResponse(status, statusCode);
+            //
+            //
+            //     throw ClientError.fromError(requestError);
+            // }
+            throw ClientError.fromError(requestError);
         }
     }
     static isJson(response) {

package/dist/Http/OAuthClient.js

@@ -28,14 +28,23 @@ export class OAuthClient {
             // Client credentials flow
             const getClientCredentials = clientCredentials(this.getAxiosInstance(), this.getApiEndpointUrl(this.options.accessTokenUri), this.options.clientId === null ? undefined : this.options.clientId, this.options.clientSecret === null ? undefined : this.options.clientSecret);
             const rawAuthToken = await getClientCredentials(this.options.scopes.join(' '));
+            console.log('Faw token', rawAuthToken);
             this.oathClientToken = this.tokenToOauthClientToken(rawAuthToken);
+            // const getRefreshToken = refreshToken(
+            //     this.getAxiosInstance(),
+            //     this.getApiEndpointUrl(this.options.accessTokenUri),
+            //     this.options.clientId === null ? undefined : this.options.clientId,
+            //     this.options.clientSecret === null ? undefined : this.options.clientSecret,
+            // );
+            // const auth = await getRefreshToken(this.oathClientToken.access_token, this.options.scopes.join(' '))
+            // console.log('Refresh token', auth);
             return true;
         }
-        catch (e) {
+        catch (requestError) {
             if (this.debug) {
-                console.debug('[Client] Error during authentication', e);
+                console.debug('[Client] Error during authentication', requestError);
             }
-            throw ClientError.fromError(e);
+            throw ClientError.fromError(requestError);
         }
     }
     async refreshToken() {

package/dist/Service/Endpoint.js

@@ -74,6 +74,10 @@ export class Endpoint {
         if (action instanceof QueryString) {
             action = action.build();
         }
+        try {
+        }
+        catch (e) {
+        }
         const requestResponse = await this.httpClient.request(action, parameters, method, signWithOauthToken);
         const result = new CollectionResult();
         /**

package/dist/Service/FirewallEndpoint.d.ts

@@ -2,17 +2,20 @@ import { Endpoint } from './Endpoint.js';
 import { CollectionResult } from '../Model/Result/CollectionResult.js';
 import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
 export type BlockedIp = {
+    id: string;
     ip: string;
     from: Date;
     to: Date;
     reason: string;
 };
 export type FlaggedIp = {
+    id: string;
     ip: string;
     date: Date;
     reason: string;
 };
 export type IpRule = {
+    id: string;
     ip: string;
     action: string;
     description: string;

package/dist/Service/FirewallEndpoint.js

@@ -5,6 +5,7 @@ export class FirewallEndpoint extends Endpoint {
     async getBlockedIps(pagination) {
         const parser = (raw) => {
             return {
+                id: raw.id,
                 ip: raw.ip,
                 from: Utils.parseRawDate(raw.from),
                 to: Utils.parseRawDate(raw.to),
@@ -19,6 +20,7 @@ export class FirewallEndpoint extends Endpoint {
     async getFlaggedIps(pagination) {
         const parser = (raw) => {
             return {
+                id: raw.id,
                 ip: raw.ip,
                 date: Utils.parseRawDate(raw.date),
                 reason: raw.reason,
@@ -32,6 +34,7 @@ export class FirewallEndpoint extends Endpoint {
     async getIpRules(pagination) {
         const parser = (raw) => {
             return {
+                id: raw.id,
                 ip: raw.ip,
                 action: raw.action,
                 description: raw.description,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.16.3";
+export declare const VERSION = "1.18.4";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "1.16.3";
+export const VERSION = "1.18.4";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attlaz-client",
-  "version": "1.18.3",
+  "version": "1.18.5",
   "description": "Javascript Client to access Attlaz API",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",