attlaz-client 1.16.8 → 1.17.1

package/dist/Http/Data/QueryString.d.ts

@@ -1,9 +1,10 @@
 import { CursorPagination } from '../../Model/Pagination/CursorPagination.js';
 import { State } from '../../Model/State.js';
 export declare class QueryString {
-    private readonly command;
+    private command;
     private parameters;
-    constructor(command: string);
+    constructor(command?: string);
+    setCommand(command: string): void;
     set(parameter: string, value: string | number | boolean | string[]): void;
     addPagination(pagination: CursorPagination | null): void;
     addStateFilter(states: State[] | null): void;

package/dist/Http/Data/QueryString.js

@@ -1,7 +1,10 @@
 export class QueryString {
     command;
     parameters = [];
-    constructor(command) {
+    constructor(command = '') {
+        this.command = command;
+    }
+    setCommand(command) {
         this.command = command;
     }
     set(parameter, value) {

package/dist/Http/HttpClient.d.ts

@@ -12,7 +12,7 @@ export declare class HttpClient {
     static HTTP_UNAVAILABLE: number;
     static HTTP_TIMEOUT: number;
     static request(request: HttpClientRequest): Promise<HttpClientResponse>;
-    private static popsicleRequest;
+    private static axiosRequest;
     private static isJson;
     static formatContentType(input: string): {
         type: string;

package/dist/Http/HttpClient.js

@@ -1,4 +1,5 @@
-import { fetch } from 'popsicle';
+// import {fetch} from 'popsicle';
+import axios from 'axios';
 import { HttpClientResponse } from './HttpClientResponse.js';
 import { ClientError } from './ClientError.js';
 export class HttpClient {
@@ -13,7 +14,7 @@ export class HttpClient {
     static HTTP_UNAVAILABLE = 503;
     static HTTP_TIMEOUT = 504;
     static async request(request) {
-        const response = await HttpClient.popsicleRequest(request);
+        const response = await HttpClient.axiosRequest(request);
         // const response: HttpClientResponse = await HttpClient.superAgentRequest(request);
         const error = ClientError.byStatus(response.status, response.statusText);
         if (error !== null && error !== undefined) {
@@ -24,39 +25,74 @@ export class HttpClient {
         }
         return response;
     }
-    static async popsicleRequest(request) {
-        const rawRequest = {
+    static async axiosRequest(request) {
+        const requestConfig = {
             url: request.getFullUrl(),
             method: request.method,
             headers: request.headers,
-            omitDefaultHeaders: true,
-            body: request.body,
+            data: request.body,
         };
-        const rawResponse = await fetch(request.getFullUrl(), rawRequest);
+        // TODO: should we share this instance between requests?
+        const axiosInstance = axios.create();
+        const rawResponse = await axiosInstance.request(requestConfig);
         const httpResponse = new HttpClientResponse(rawResponse.status, rawResponse.statusText);
-        for (const header of rawResponse.headers.keys()) {
-            const headerValue = rawResponse.headers.get(header);
+        Object.keys(rawResponse.headers).forEach((header) => {
+            const headerValue = rawResponse.headers[header];
             httpResponse.headers[header] = headerValue === null ? '' : headerValue;
-        }
-        httpResponse.body = await rawResponse.text();
-        if (HttpClient.isJson(httpResponse)) {
-            let jsonData = null;
-            if (httpResponse.body !== '') {
-                try {
-                    jsonData = JSON.parse(httpResponse.body);
-                }
-                catch (e) {
-                    // console.error(, {statusText: httpResponse.statusText, error: e});
-                    throw new Error('Unable to parse response data to JSON');
-                }
-            }
-            httpResponse.body = jsonData;
-        }
-        else {
-            // response.body = rawData;
-        }
+        });
+        // console.log('Raw', rawResponse.data);
+        // console.log('Is json', HttpClient.isJson(httpResponse));
+        httpResponse.body = await rawResponse.data;
+        // if (HttpClient.isJson(httpResponse)) {
+        //     let jsonData: object | null = null;
+        //     if (httpResponse.body !== '') {
+        //         try {
+        //             jsonData = JSON.parse(httpResponse.body);
+        //         } catch (e) {
+        //             // console.error(, {statusText: httpResponse.statusText, error: e});
+        //             throw new Error('Unable to parse response data to JSON');
+        //         }
+        //     }
+        //     httpResponse.body = jsonData;
+        // } else {
+        //     // response.body = rawData;
+        // }
         return httpResponse;
     }
+    // private static async popsicleRequest(request: HttpClientRequest): Promise<HttpClientResponse> {
+    // const rawRequest: CommonRequestOptions<any> = {
+    //     url: request.getFullUrl(),
+    //     method: request.method,
+    //     headers: request.headers,
+    //     omitDefaultHeaders: true,
+    //     body: request.body,
+    // } as CommonRequestOptions<any>;
+    // const rawResponse: PopsicleResponse = await fetch(request.getFullUrl(), rawRequest);
+    // const httpResponse: HttpClientResponse = new HttpClientResponse(rawResponse.status, rawResponse.statusText);
+    // for (const header of rawResponse.headers.keys()) {
+    //     const headerValue: string | null = rawResponse.headers.get(header);
+    //     httpResponse.headers[header] = headerValue === null ? '' : headerValue;
+    // }
+    //
+    // httpResponse.body = await rawResponse.text();
+    // if (HttpClient.isJson(httpResponse)) {
+    //     let jsonData: object | null = null;
+    //     if (httpResponse.body !== '') {
+    //         try {
+    //             jsonData = JSON.parse(httpResponse.body);
+    //         } catch (e) {
+    //             // console.error(, {statusText: httpResponse.statusText, error: e});
+    //             throw new Error('Unable to parse response data to JSON');
+    //         }
+    //     }
+    //     httpResponse.body = jsonData;
+    // } else {
+    //     // response.body = rawData;
+    // }
+    //
+    //
+    // return httpResponse;
+    //  }
     // private static async superAgentRequest(request: HttpClientRequest): Promise<HttpClientResponse> {
     //
     //

package/dist/Http/OAuthClient.d.ts

@@ -2,17 +2,18 @@ import { OAuthClientOptions } from './OAuthClientOptions.js';
 import { OAuthClientToken } from './OAuthClientToken.js';
 import { Parameters } from './Data/Parameters.js';
 import { Headers } from './Data/Headers.js';
+import { QueryString } from './Data/QueryString.js';
 export declare class OAuthClient {
     private readonly options;
     private debug;
-    private oauthClient;
-    private oauthToken;
+    private axiosInstance;
     private oathClientToken;
     private refreshTokenPromise;
     constructor(options: OAuthClientOptions);
     authenticate(username: string, password: string): Promise<boolean>;
     authenticate(): Promise<boolean>;
     refreshToken(): Promise<void>;
+    private getAxiosInstance;
     isTokenExpires(): boolean;
     request(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean): Promise<any>;
     isAuthenticated(): boolean;
@@ -22,15 +23,11 @@ export declare class OAuthClient {
     enableDebug(): void;
     disableDebug(): void;
     isDebugEnabled(): boolean;
-    getTokenFlowUrl(options?: {
-        query?: {
-            [key: string]: string | string[];
-        };
-    } | null): string;
+    getTokenFlowUrl(options?: QueryString | null): string;
     getDefaultHeaders(): Headers;
     private isNodeEnvironment;
     private tokenToOauthClientToken;
-    private getUri;
+    private getApiEndpointUrl;
     private createRequestData;
     private signRequest;
 }

package/dist/Http/OAuthClient.js

@@ -1,45 +1,54 @@
-import ClientOAuth2 from 'client-oauth2';
+// import ClientOAuth2, {Token} from 'client-oauth2';
+import { clientCredentials, ownerCredentials, refreshToken } from 'axios-oauth-client';
+import axios from 'axios';
 import { ClientError } from './ClientError.js';
 import { HttpClient } from './HttpClient.js';
 import { HttpClientRequest } from './HttpClientRequest.js';
 import { OAuthClientToken } from './OAuthClientToken.js';
 import { JsonSerializable } from '../Model/JsonSerializable.js';
 import { VERSION } from '../version.js';
+import { QueryString } from './Data/QueryString.js';
 export class OAuthClient {
     options;
     debug = false;
-    oauthClient;
-    oauthToken = null;
+    axiosInstance = null;
+    // private oauthClient: ClientOAuth2;
+    // private oauthToken: Token | null = null;
     oathClientToken = null;
     refreshTokenPromise = null;
     constructor(options) {
         this.options = options;
-        this.oauthClient = new ClientOAuth2({
-            clientId: options.clientId === null ? undefined : options.clientId,
-            clientSecret: options.clientSecret === null ? undefined : options.clientSecret,
-            accessTokenUri: this.getUri(options.accessTokenUri),
-            authorizationUri: this.getUri(options.authorizationUri),
-            redirectUri: options.redirectUri,
-            scopes: options.scopes,
-            state: options.state,
-            headers: this.getDefaultHeaders(),
-        });
+        // this.oauthClient = new ClientOAuth2({
+        //     clientId: options.clientId === null ? undefined : options.clientId,
+        //     clientSecret: options.clientSecret === null ? undefined : options.clientSecret,
+        //     accessTokenUri: this.getUri(options.accessTokenUri),
+        //     authorizationUri: this.getUri(options.authorizationUri),
+        //     redirectUri: options.redirectUri,
+        //     scopes: options.scopes,
+        //     state: options.state,
+        //     headers: this.getDefaultHeaders(),
+        // });
     }
     async authenticate(username = null, password = null) {
         // TODO: should we encrypt the password in the client (or is https save enough)?
         try {
-            let accessToken;
             if (username !== null && username !== undefined && password !== null && password !== undefined) {
-                // Password flow
-                accessToken = await this.oauthClient.owner.getToken(username, password);
+                // Password flow / Owner Credentials grant
+                const getOwnerCredentials = ownerCredentials(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 getOwnerCredentials(username, password, 'OPTIONAL_SCOPES');
+                this.oathClientToken = this.tokenToOauthClientToken(rawAuthToken);
+                // accessToken = await this.oauthClient.owner.getToken(username, password);
+                return true;
             }
-            else {
-                // Client credentials flow
-                accessToken = await this.oauthClient.credentials.getToken();
-            }
-            this.oauthToken = accessToken;
-            this.oathClientToken = this.tokenToOauthClientToken(this.oauthToken);
+            // 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('OPTIONAL_SCOPES');
+            this.oathClientToken = this.tokenToOauthClientToken(rawAuthToken);
+            // accessToken = await this.oauthClient.credentials.getToken();
             return true;
+            // this.oauthToken = accessToken;
+            // this.oathClientToken = this.tokenToOauthClientToken(rawAuthToken);
+            // return true;
         }
         catch (e) {
             if (this.debug) {
@@ -52,25 +61,37 @@ export class OAuthClient {
         if (this.debug) {
             console.debug('[OAuthClient] refresh token');
         }
-        if (this.oauthToken === null) {
+        if (this.oathClientToken === null) {
             throw new Error('unable to refresh token, auth token not set');
         }
-        if (this.oauthToken.refreshToken === undefined || this.oauthToken.refreshToken === null || this.oauthToken.refreshToken === '') {
+        if (this.oathClientToken.refresh_token === undefined || this.oathClientToken.refresh_token === null || this.oathClientToken.refresh_token === '') {
             throw new Error('unable to refresh token, refresh token not set');
         }
         try {
-            this.oauthToken = await this.oauthToken.refresh();
-            this.oathClientToken = this.tokenToOauthClientToken(this.oauthToken);
+            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.refresh_token, 'OPTIONAL_SCOPES');
+            // this.oauthToken = await this.oauthToken.refresh();
+            this.oathClientToken = this.tokenToOauthClientToken(auth);
         }
         catch (e) {
             throw ClientError.fromError(e);
         }
     }
+    getAxiosInstance() {
+        if (this.axiosInstance === null) {
+            this.axiosInstance = axios.create({
+            // httpsAgent: new https.Agent({
+            //     rejectUnauthorized: false,
+            // }),
+            });
+        }
+        return this.axiosInstance;
+    }
     isTokenExpires() {
-        if (this.oauthToken === null) {
+        if (this.oathClientToken === null) {
             throw new Error('No token defined');
         }
-        return this.oauthToken.expired();
+        return OAuthClientToken.isExpired(this.oathClientToken);
     }
     async request(action, parameters = null, method = 'GET', signWithOauthToken = true) {
         if (signWithOauthToken && !this.isAuthenticated()) {
@@ -78,10 +99,10 @@ export class OAuthClient {
         }
         else {
             if (signWithOauthToken) {
-                if (this.oauthToken === null) {
+                if (this.oathClientToken === null) {
                     throw new ClientError('Unable to perform request, access token not provided');
                 }
-                if (signWithOauthToken && this.oauthToken.expired()) {
+                if (signWithOauthToken && OAuthClientToken.isExpired(this.oathClientToken)) {
                     if (this.refreshTokenPromise === null) {
                         this.refreshTokenPromise = this.refreshToken();
                         await this.refreshTokenPromise;
@@ -120,30 +141,25 @@ export class OAuthClient {
         return this.oathClientToken !== null && this.oathClientToken !== undefined;
     }
     getToken() {
-        if (this.oauthToken === null) {
-            return null;
-        }
-        if (this.oathClientToken === null) {
-            this.oathClientToken = this.tokenToOauthClientToken(this.oauthToken);
-        }
         return this.oathClientToken;
     }
     setToken(token) {
-        const data = {
-            access_token: token.access_token,
-            token_type: token.token_type,
-            refresh_token: token.refresh_token,
-            scope: token.scope,
-        };
-        const oauthToken = this.oauthClient.createToken(data);
-        if (token.expires !== null && token.expires !== undefined) {
-            oauthToken.expiresIn(token.expires);
-        }
-        this.oauthToken = oauthToken;
+        // const data: {} = {
+        //     access_token: token.access_token,
+        //     token_type: token.token_type,
+        //     refresh_token: token.refresh_token,
+        //     scope: token.scope,
+        //
+        // };
+        // const oauthToken: Token = this.oauthClient.createToken(data);
+        // if (token.expires !== null && token.expires !== undefined) {
+        //     oauthToken.expiresIn(token.expires);
+        // }
+        // this.oauthToken = oauthToken;
         this.oathClientToken = token;
     }
     unsetToken() {
-        this.oauthToken = null;
+        // this.oauthToken = null;
         this.oathClientToken = null;
     }
     enableDebug() {
@@ -156,7 +172,11 @@ export class OAuthClient {
         return this.debug;
     }
     getTokenFlowUrl(options = null) {
-        return this.oauthClient.token.getUri(options === null ? undefined : options);
+        if (options === null) {
+            options = new QueryString();
+        }
+        options.setCommand(this.getApiEndpointUrl(this.options.accessTokenUri));
+        return options.build();
     }
     getDefaultHeaders() {
         const userAgentInfo = {
@@ -175,28 +195,28 @@ export class OAuthClient {
         return typeof process !== 'undefined' && process.versions != null && process.versions.node != null;
     }
     tokenToOauthClientToken(oauthToken) {
-        let scopes = '';
-        if (Object.prototype.hasOwnProperty.call(oauthToken.data, 'scopes')) {
-            scopes = oauthToken.data.scopes;
-        }
-        else if (Object.prototype.hasOwnProperty.call(oauthToken.data, 'scope')) {
-            scopes = oauthToken.data.scope;
-        }
-        const token = new OAuthClientToken(oauthToken.accessToken, oauthToken.tokenType, oauthToken.refreshToken, scopes);
-        const rawTokenExpires = oauthToken.expires;
-        if (rawTokenExpires !== null && rawTokenExpires !== undefined) {
-            token.expires = rawTokenExpires;
-        }
+        // console.log('Auth token', oauthToken);
+        // let scopes: string = '';
+        // if (Object.prototype.hasOwnProperty.call(oauthToken.data, 'scopes')) {
+        //     scopes = oauthToken.data.scopes;
+        // } else if (Object.prototype.hasOwnProperty.call(oauthToken.data, 'scope')) {
+        //     scopes = oauthToken.data.scope;
+        // }
+        const refreshToken = oauthToken.refresh_token === undefined || oauthToken.refresh_token === null ? null : oauthToken.refresh_token;
+        const token = new OAuthClientToken(oauthToken.access_token, oauthToken.token_type, refreshToken, oauthToken.scope);
+        const t = new Date();
+        t.setSeconds(t.getSeconds() + oauthToken.expires_in);
+        token.expires = t;
         return token;
     }
-    getUri(uri) {
+    getApiEndpointUrl(uri) {
         if (uri.indexOf('http://') === 0 || uri.indexOf('https://') === 0) {
             return uri;
         }
         return this.options.apiEndpoint.replace(/\/+$/, '') + '/' + uri.replace(/^\/+/g, '');
     }
     createRequestData(action, parameters = null, method = 'GET', signWithOauthToken = true) {
-        const url = this.getUri(action);
+        const url = this.getApiEndpointUrl(action);
         let requestData = new HttpClientRequest(url, method);
         requestData.headers = this.getDefaultHeaders();
         if ((method === 'POST' || method === 'DELETE' || method === 'PUT') && parameters !== null && parameters !== undefined) {
@@ -219,22 +239,23 @@ export class OAuthClient {
             });
         }
         if (signWithOauthToken) {
-            if (this.oauthToken === null) {
+            if (this.oathClientToken === null) {
                 throw new ClientError('Unable to perform request, access token not provided');
             }
-            if (this.oauthToken.expired()) {
+            if (OAuthClientToken.isExpired(this.oathClientToken)) {
                 throw new Error('Unable to sign request, token is expired');
             }
             requestData = this.signRequest(requestData);
         }
-        else {
-        }
         return requestData;
     }
     signRequest(requestObject) {
         if (this.oathClientToken === null) {
             throw new ClientError('Unable to sign request, access token not provided');
         }
+        if (OAuthClientToken.isExpired(this.oathClientToken)) {
+            throw new Error('Unable to sign request, token is expired');
+        }
         const tokenType = this.oathClientToken.token_type;
         const accessToken = this.oathClientToken.access_token;
         if (tokenType !== undefined && tokenType.toLowerCase() === 'bearer') {

package/dist/Http/OAuthClientToken.d.ts

@@ -4,7 +4,7 @@ export declare class OAuthClientToken {
     refresh_token: string | null;
     expires: Date | null;
     scope: string;
-    constructor(access_token: string, token_type: string, refresh_token: string, scope: string);
+    constructor(access_token: string, token_type: string, refresh_token: string | null, scope: string);
     static isExpired(token: OAuthClientToken): boolean;
     static serialize(token: OAuthClientToken): string;
     static deserialize(serializedToken: string): OAuthClientToken;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attlaz-client",
-  "version": "1.16.8",
+  "version": "1.17.1",
   "description": "Javascript Client to access Attlaz API",
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
@@ -41,8 +41,8 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "client-oauth2": "^4.3.3",
-    "popsicle": "^12.1.0"
+    "axios": "^1.7.7",
+    "axios-oauth-client": "^2.2.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.2",