attlaz-client 1.18.5 → 1.18.7

package/dist/Http/ClientError.d.ts

@@ -1,10 +1,10 @@
 import { AxiosError } from 'axios';
 export declare class ClientError extends Error {
-    httpErrorCode: number | null;
+    httpStatus: number | null;
     type: string;
     code: string;
     message: string;
-    param?: string;
+    param?: string | undefined;
     stack?: string;
     constructor(code: string, httpErrorCode?: number | null);
     static fromError(error: Error | AxiosError): ClientError;

package/dist/Http/ClientError.js

@@ -1,33 +1,48 @@
 import { AxiosError } from 'axios';
-import { HttpClient } from './HttpClient.js';
+import { HttpStatus } from './HttpStatus.js';
 export class ClientError extends Error {
-    httpErrorCode = null;
+    httpStatus = null;
     type;
     code;
     message;
     param = undefined;
-    stack = undefined;
+    stack;
     constructor(code, httpErrorCode = null) {
         super(code);
         this.code = code;
-        this.httpErrorCode = httpErrorCode;
+        this.httpStatus = httpErrorCode;
     }
     static fromError(error) {
-        let clientError = new ClientError('Unknown error', HttpClient.HTTP_INTERNAL_SERVER_ERROR);
+        let clientError = new ClientError('Unknown error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
         if (error instanceof AxiosError) {
             if (error.status !== undefined) {
-                clientError.httpErrorCode = error.status;
+                clientError.httpStatus = 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;
+            // console.log('Status', clientError.httpStatus);
+            // if(clientError.httpStatus === HttpStatusCode.Ref)
+            clientError.message = error.message;
+            if (error.code !== undefined) {
+                clientError.code = error.code;
             }
-            else {
+            if (error.response === undefined) {
                 console.error('Unable to parse AxiosError response', { error });
             }
+            else {
+                // console.debug('Parse response', {error: error, data: error.response.data});
+                const errorData = error.response.data;
+                if (errorData.type !== undefined) {
+                    clientError.type = errorData.type;
+                }
+                if (errorData.code !== undefined) {
+                    clientError.code = errorData.code;
+                }
+                if (errorData.message !== undefined) {
+                    clientError.message = errorData.message;
+                }
+                if (errorData.param !== undefined) {
+                    clientError.param = errorData.param;
+                }
+            }
             return clientError;
         }
         // if (error.body !== undefined && error.body !== null && error.body.error !== undefined && error.body.error !== null) {
@@ -51,23 +66,23 @@ export class ClientError extends Error {
         else if (xError.code !== null && xError.code !== undefined) {
             switch (xError.code) {
                 case 'EUNAVAILABLE':
-                    clientError.httpErrorCode = HttpClient.HTTP_UNAVAILABLE;
+                    clientError.httpStatus = HttpStatus.HTTP_UNAVAILABLE;
                     break;
                 case 'EAUTH':
                 case 401:
-                    clientError.httpErrorCode = HttpClient.HTTP_UNAUTHORIZED;
+                    clientError.httpStatus = HttpStatus.HTTP_UNAUTHORIZED;
                     break;
                 case 'ESTATUS':
                     if (error.message === 'HTTP status 503') {
-                        clientError.httpErrorCode = HttpClient.HTTP_UNAVAILABLE;
+                        clientError.httpStatus = HttpStatus.HTTP_UNAVAILABLE;
                     }
                     break;
                 case 500:
-                    clientError.httpErrorCode = HttpClient.HTTP_INTERNAL_SERVER_ERROR;
+                    clientError.httpStatus = HttpStatus.HTTP_INTERNAL_SERVER_ERROR;
                     break;
                 default:
                     console.warn('[Client error] Error code `' + xError.code + '` not recognised');
-                    clientError.httpErrorCode = HttpClient.HTTP_INTERNAL_SERVER_ERROR;
+                    clientError.httpStatus = HttpStatus.HTTP_INTERNAL_SERVER_ERROR;
             }
         }
         clientError.name = error.name;
@@ -82,25 +97,25 @@ export class ClientError extends Error {
             case 202:
                 return null;
             case 400:
-                return new ClientError('Bad Request', HttpClient.HTTP_BAD_REQUEST);
+                return new ClientError('Bad Request', HttpStatus.HTTP_BAD_REQUEST);
             case 401:
-                return new ClientError('Unauthorized', HttpClient.HTTP_UNAUTHORIZED);
+                return new ClientError('Unauthorized', HttpStatus.HTTP_UNAUTHORIZED);
             case 403:
-                return new ClientError('Forbidden', HttpClient.HTTP_FORBIDDEN);
+                return new ClientError('Forbidden', HttpStatus.HTTP_FORBIDDEN);
             case 404:
-                return new ClientError('Not Found', HttpClient.HTTP_NOTFOUND);
+                return new ClientError('Not Found', HttpStatus.HTTP_NOTFOUND);
             case 405:
-                return new ClientError('Not allowed', HttpClient.HTTP_NOT_ALLOWED);
+                return new ClientError('Not allowed', HttpStatus.HTTP_NOT_ALLOWED);
             case 422:
-                return new ClientError('Unprocessable Entity', HttpClient.HTTP_UNPROCESSABLE_ENTITY);
+                return new ClientError('Unprocessable Entity', HttpStatus.HTTP_UNPROCESSABLE_ENTITY);
             case 500:
-                return new ClientError('Internal Server Error', HttpClient.HTTP_INTERNAL_SERVER_ERROR);
+                return new ClientError('Internal Server Error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
             case 502:
-                return new ClientError('Bad gateway', HttpClient.HTTP_BAD_GATEWAY);
+                return new ClientError('Bad gateway', HttpStatus.HTTP_BAD_GATEWAY);
             case 503:
-                return new ClientError('Service not available', HttpClient.HTTP_UNAVAILABLE);
+                return new ClientError('Service not available', HttpStatus.HTTP_UNAVAILABLE);
             case 504:
-                return new ClientError('Gateway Time-out', HttpClient.HTTP_TIMEOUT);
+                return new ClientError('Gateway Time-out', HttpStatus.HTTP_TIMEOUT);
             default:
                 console.error('Unknown status code "' + statusCode + '"', { code: statusCode, text: statusText });
                 return new ClientError('Status code ' + statusCode + ': ' + statusText, statusCode);

package/dist/Http/ContentTypeHelper.d.ts

@@ -0,0 +1,6 @@
+export declare class ContentTypeHelper {
+    static formatContentType(input: string): {
+        type: string;
+        options: string | null;
+    };
+}

package/dist/Http/ContentTypeHelper.js

@@ -0,0 +1,13 @@
+export class ContentTypeHelper {
+    static formatContentType(input) {
+        const arrInput = input.split(';');
+        if (arrInput.length === 1) {
+            return { type: arrInput[0], options: null };
+        }
+        if (arrInput.length === 2) {
+            return { type: arrInput[0], options: arrInput[1].trim() };
+        }
+        console.error('Unable to parse content type "' + input + '"');
+        return { type: input, options: null };
+    }
+}

package/dist/Http/HttpClient.d.ts

@@ -1,21 +1,6 @@
 import { HttpClientRequest } from './HttpClientRequest.js';
 import { HttpClientResponse } from './HttpClientResponse.js';
 export declare class HttpClient {
-    static HTTP_BAD_REQUEST: number;
-    static HTTP_UNAUTHORIZED: number;
-    static HTTP_FORBIDDEN: number;
-    static HTTP_NOTFOUND: number;
-    static HTTP_NOT_ALLOWED: number;
-    static HTTP_UNPROCESSABLE_ENTITY: number;
-    static HTTP_INTERNAL_SERVER_ERROR: number;
-    static HTTP_BAD_GATEWAY: number;
-    static HTTP_UNAVAILABLE: number;
-    static HTTP_TIMEOUT: number;
     static request(request: HttpClientRequest): Promise<HttpClientResponse>;
     private static axiosRequest;
-    private static isJson;
-    static formatContentType(input: string): {
-        type: string;
-        options: string | null;
-    };
 }

package/dist/Http/HttpClient.js

@@ -2,16 +2,6 @@ import axios from 'axios';
 import { HttpClientResponse } from './HttpClientResponse.js';
 import { ClientError } from './ClientError.js';
 export class HttpClient {
-    static HTTP_BAD_REQUEST = 400;
-    static HTTP_UNAUTHORIZED = 401;
-    static HTTP_FORBIDDEN = 403;
-    static HTTP_NOTFOUND = 404;
-    static HTTP_NOT_ALLOWED = 405;
-    static HTTP_UNPROCESSABLE_ENTITY = 422;
-    static HTTP_INTERNAL_SERVER_ERROR = 500;
-    static HTTP_BAD_GATEWAY = 502;
-    static HTTP_UNAVAILABLE = 503;
-    static HTTP_TIMEOUT = 504;
     static async request(request) {
         const response = await HttpClient.axiosRequest(request);
         // const error: ClientError | null = ClientError.byStatus(response.status, response.statusText);
@@ -60,18 +50,4 @@ export class HttpClient {
             throw ClientError.fromError(requestError);
         }
     }
-    static isJson(response) {
-        return response.getContentType() === 'application/json';
-    }
-    static formatContentType(input) {
-        const d = input.split(';');
-        if (d.length === 1) {
-            return { type: d[0], options: null };
-        }
-        if (d.length === 2) {
-            return { type: d[0], options: d[1].trim() };
-        }
-        console.error('Unable to parse content type "' + input + '"');
-        return { type: input, options: null };
-    }
 }

package/dist/Http/HttpClientResponse.d.ts

@@ -6,4 +6,5 @@ export declare class HttpClientResponse {
     headers: Headers;
     constructor(status: number, statusText: string);
     getContentType(): string | null;
+    isJson(): boolean;
 }

package/dist/Http/HttpClientResponse.js

@@ -1,4 +1,4 @@
-import { HttpClient } from './HttpClient.js';
+import { ContentTypeHelper } from './ContentTypeHelper.js';
 export class HttpClientResponse {
     status;
     statusText;
@@ -20,7 +20,10 @@ export class HttpClientResponse {
         if (contentType === null || contentType === undefined) {
             return null;
         }
-        const parsedContentType = HttpClient.formatContentType(contentType);
+        const parsedContentType = ContentTypeHelper.formatContentType(contentType);
         return parsedContentType.type;
     }
+    isJson() {
+        return this.getContentType() === 'application/json';
+    }
 }

package/dist/Http/HttpStatus.d.ts

@@ -0,0 +1,12 @@
+export declare class HttpStatus {
+    static HTTP_BAD_REQUEST: number;
+    static HTTP_UNAUTHORIZED: number;
+    static HTTP_FORBIDDEN: number;
+    static HTTP_NOTFOUND: number;
+    static HTTP_NOT_ALLOWED: number;
+    static HTTP_UNPROCESSABLE_ENTITY: number;
+    static HTTP_INTERNAL_SERVER_ERROR: number;
+    static HTTP_BAD_GATEWAY: number;
+    static HTTP_UNAVAILABLE: number;
+    static HTTP_TIMEOUT: number;
+}

package/dist/Http/HttpStatus.js

@@ -0,0 +1,12 @@
+export class HttpStatus {
+    static HTTP_BAD_REQUEST = 400;
+    static HTTP_UNAUTHORIZED = 401;
+    static HTTP_FORBIDDEN = 403;
+    static HTTP_NOTFOUND = 404;
+    static HTTP_NOT_ALLOWED = 405;
+    static HTTP_UNPROCESSABLE_ENTITY = 422;
+    static HTTP_INTERNAL_SERVER_ERROR = 500;
+    static HTTP_BAD_GATEWAY = 502;
+    static HTTP_UNAVAILABLE = 503;
+    static HTTP_TIMEOUT = 504;
+}

package/dist/Http/OAuthClient.js

@@ -28,7 +28,7 @@ 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);
+            // console.log('Raw token', rawAuthToken);
             this.oathClientToken = this.tokenToOauthClientToken(rawAuthToken);
             // const getRefreshToken = refreshToken(
             //     this.getAxiosInstance(),
@@ -121,6 +121,9 @@ export class OAuthClient {
                     }
                     throw clientError;
                 }
+                if (this.debug) {
+                    console.error('[Client] Error:', { error });
+                }
                 throw error;
             }
         }

package/dist/Service/Endpoint.js

@@ -1,12 +1,12 @@
 import { CollectionResult } from '../Model/Result/CollectionResult.js';
 import { ObjectResult } from '../Model/Result/ObjectResult.js';
-import { HttpClient } from '../Http/HttpClient.js';
 import { Utils } from '../Utils.js';
 import { ObjectWrapper } from '../Model/Result/ObjectWrapper.js';
 import { DataValueCollection } from '../Model/DataValueCollection.js';
 import { JsonSerializable } from '../Model/JsonSerializable.js';
 import { LogStreamId } from '../Model/Log/LogStreamId.js';
 import { QueryString } from '../Http/Data/QueryString.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 export class Endpoint {
     httpClient;
     constructor(httpClient) {
@@ -123,7 +123,7 @@ export class Endpoint {
             result.setData(this.parseObject(requestResponse, parser));
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 result.setData(null);
             }
             else {

package/dist/Service/FlowEndpoint.js

@@ -1,8 +1,8 @@
 import { Endpoint } from './Endpoint.js';
 import { Utils } from '../Utils.js';
-import { HttpClient } from '../Http/HttpClient.js';
 import { Flow } from '../Model/Flow/Flow.js';
 import { FlowSummary } from '../Model/Flow/FlowSummary.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 export class FlowEndpoint extends Endpoint {
     async getByProject(projectId) {
         try {
@@ -23,7 +23,7 @@ export class FlowEndpoint extends Endpoint {
             return result.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/ProjectEnvironmentEndpoint.js

@@ -1,7 +1,7 @@
 import { Endpoint } from './Endpoint.js';
 import { ProjectEnvironment } from '../Model/Project/ProjectEnvironment.js';
-import { HttpClient } from '../Http/HttpClient.js';
 import { ProjectEnvironmentConfiguration } from '../Model/Project/ProjectEnvironmentConfiguration.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 export class ProjectEnvironmentEndpoint extends Endpoint {
     async getByProject(id) {
         try {
@@ -21,7 +21,7 @@ export class ProjectEnvironmentEndpoint extends Endpoint {
             return rawProjectEnvironment.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {
@@ -60,7 +60,7 @@ export class ProjectEnvironmentEndpoint extends Endpoint {
             return rawProjectEnvironment.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/SourcesAccountEndpoint.js

@@ -1,10 +1,10 @@
 import { Endpoint } from './Endpoint.js';
 import { CodeSourceAccount } from '../Model/Deployment/CodeSourceAccount.js';
 import { CodeSource } from '../Model/Deployment/CodeSource.js';
-import { HttpClient } from '../Http/HttpClient.js';
 import { SourcesAccountRepository } from '../Model/Deployment/SourcesAccountRepository.js';
 import { SourcesAccountRepositoryBranch } from '../Model/Deployment/SourcesAccountRepositoryBranch.js';
 import { QueryString } from '../Http/Data/QueryString.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 export class SourcesAccountEndpoint extends Endpoint {
     async getAllCodeSources(workspaceId, pagination = null) {
         const queryString = new QueryString('workspaces/' + workspaceId + '/codesources');
@@ -24,7 +24,7 @@ export class SourcesAccountEndpoint extends Endpoint {
             return rawSourcesAccounts.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {
@@ -44,7 +44,7 @@ export class SourcesAccountEndpoint extends Endpoint {
             return result.getData();
         }
         catch (error) {
-            if (error.code === HttpClient.HTTP_NOTFOUND) {
+            if (error.httpStatus === HttpStatus.HTTP_NOTFOUND) {
                 return null;
             }
             if (this.httpClient.isDebugEnabled()) {

package/dist/index.d.ts

@@ -11,6 +11,8 @@ export { OAuthClient } from './Http/OAuthClient.js';
 export { OAuthClientOptions } from './Http/OAuthClientOptions.js';
 export { OAuthClientToken } from './Http/OAuthClientToken.js';
 export { ClientError } from './Http/ClientError.js';
+export { HttpStatus } from './Http/HttpStatus.js';
+export { ContentTypeHelper } from './Http/ContentTypeHelper.js';
 /**
  * Models
  */

package/dist/index.js

@@ -6,6 +6,8 @@ export { OAuthClient } from './Http/OAuthClient.js';
 export { OAuthClientOptions } from './Http/OAuthClientOptions.js';
 export { OAuthClientToken } from './Http/OAuthClientToken.js';
 export { ClientError } from './Http/ClientError.js';
+export { HttpStatus } from './Http/HttpStatus.js';
+export { ContentTypeHelper } from './Http/ContentTypeHelper.js';
 /**
  * Models
  */

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

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