attlaz-client 1.47.2 → 1.48.1

package/dist/Client.d.ts

@@ -1,5 +1,6 @@
-import { OAuthClient } from './Http/OAuthClient.js';
 import { OAuthClientToken } from './Http/OAuthClientToken.js';
+import { ITransport } from './Http/Transport/ITransport.js';
+import { OAuthClient } from './Http/Transport/OAuthClient.js';
 import { AccessTokenEndpoint } from './Service/AccessTokenEndpoint.js';
 import { AdapterConnectionEndpoint } from './Service/AdapterConnectionEndpoint.js';
 import { AdapterEndpoint } from './Service/AdapterEndpoint.js';
@@ -36,12 +37,19 @@ import { WorkspaceMemberEndpoint } from './Service/WorkspaceMemberEndpoint.js';
 export declare class Client {
     private readonly endpoints;
     private httpClient;
+    private transport;
     private readonly Store;
     private readonly apiEndpoint;
-    private parseConfig;
     constructor(token?: string | null, config?: {
-        apiEndpoint: string | undefined;
+        apiEndpoint?: string;
     });
+    /**
+     * Create a Client that uses a custom transport instead of OAuth.
+     * Intended for internal service-to-service calls (e.g. using DirectTransport).
+     */
+    static withTransport(transport: ITransport, config?: {
+        apiEndpoint: string | undefined;
+    }): Client;
     setClientCredentials(clientId: string, clientSecret?: string): void;
     setVersion(version: string | null): void;
     getHttpClient(): OAuthClient;

package/dist/Client.js

@@ -1,6 +1,6 @@
-import { OAuthClient } from './Http/OAuthClient.js';
 import { OAuthClientOptions } from './Http/OAuthClientOptions.js';
 import { OAuthClientToken } from './Http/OAuthClientToken.js';
+import { OAuthClient } from './Http/Transport/OAuthClient.js';
 import { AccessTokenEndpoint } from './Service/AccessTokenEndpoint.js';
 import { AdapterConnectionEndpoint } from './Service/AdapterConnectionEndpoint.js';
 import { AdapterEndpoint } from './Service/AdapterEndpoint.js';
@@ -36,8 +36,9 @@ import { WorkspaceEndpoint } from './Service/WorkspaceEndpoint.js';
 import { WorkspaceMemberEndpoint } from './Service/WorkspaceMemberEndpoint.js';
 import { VERSION } from './version.js';
 export class Client {
-    endpoints;
+    endpoints = new Map();
     httpClient;
+    transport;
     Store = {
         AccessTokenEndpoint,
         AdapterConnectionEndpoint,
@@ -74,14 +75,9 @@ export class Client {
         ProviderTokenEndpoint,
     };
     apiEndpoint = 'https://api.attlaz.com';
-    parseConfig(config) {
-        // TODO: go over other records in config and warn if any unknown ones
-        return config;
-    }
-    constructor(token = null, config = { apiEndpoint: undefined }) {
-        const parsedConfig = this.parseConfig(config);
-        if (parsedConfig.apiEndpoint !== undefined) {
-            this.apiEndpoint = parsedConfig.apiEndpoint;
+    constructor(token = null, config = {}) {
+        if (config.apiEndpoint !== undefined) {
+            this.apiEndpoint = config.apiEndpoint;
         }
         const options = new OAuthClientOptions(this.apiEndpoint);
         this.httpClient = new OAuthClient(options);
@@ -89,7 +85,16 @@ export class Client {
             const clientToken = new OAuthClientToken(token, 'Bearer', '', '');
             this.httpClient.setToken(clientToken);
         }
-        this.endpoints = new Map();
+        this.transport = this.httpClient;
+    }
+    /**
+     * Create a Client that uses a custom transport instead of OAuth.
+     * Intended for internal service-to-service calls (e.g. using DirectTransport).
+     */
+    static withTransport(transport, config = { apiEndpoint: undefined }) {
+        const client = new Client(null, config);
+        client.transport = transport;
+        return client;
     }
     setClientCredentials(clientId, clientSecret = '') {
         const options = new OAuthClientOptions(this.apiEndpoint, clientId, clientSecret);
@@ -97,6 +102,7 @@ export class Client {
         options.scopes = ['all'];
         // TODO: do we need to create a new oauth client, or can we update with these credentials?
         this.httpClient = new OAuthClient(options);
+        this.transport = this.httpClient;
     }
     setVersion(version) {
         this.httpClient.setVersion(version);
@@ -204,7 +210,7 @@ export class Client {
         return this.getEndpoint('configuration', this.Store.ConfigurationEndpoint);
     }
     getHealthAlertEndpoint() {
-        return this.getEndpoint('healt-alert', this.Store.HealthAlertEndpoint);
+        return this.getEndpoint('health-alert', this.Store.HealthAlertEndpoint);
     }
     getCodeSourceStrategiesEndpoint() {
         return this.getEndpoint('code-source-strategies', this.Store.CodeSourceStrategiesEndpoint);
@@ -227,22 +233,17 @@ export class Client {
     getProviderTokenEndpoint() {
         return this.getEndpoint('provider_token', this.Store.ProviderTokenEndpoint);
     }
-    // TODO: this should be in a separate API?
     getFirewallEndpoint() {
         return this.getEndpoint('firewall', this.Store.FirewallEndpoint);
     }
     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);
-                this.endpoints.set(key, endpoint);
+                this.endpoints.set(key, new ClassName(this.transport));
             }
             catch (error) {
-                throw new Error('Unable to initialize ' + key + ' endpoint (' + error.message + ')');
+                const errorMsg = (error !== null && typeof error === 'object' && 'message' in error && typeof error.message === 'string') ? error.message : 'Unknown';
+                throw new Error('Unable to initialize ' + key + ' endpoint (' + errorMsg + ')');
             }
         }
         return this.endpoints.get(key);

package/dist/Http/ClientError.js

@@ -14,7 +14,6 @@ export class ClientError extends Error {
         if (error instanceof AxiosError) {
             if (error.code === 'ECONNREFUSED' || error.code === 'ERR_NETWORK') {
                 clientError.httpStatus = HttpStatus.HTTP_UNAVAILABLE;
-                // clientError.code = 'Service not available';
                 clientError.message = 'Service not available';
                 return clientError;
             }
@@ -24,9 +23,6 @@ export class ClientError extends Error {
             // console.log('Status', clientError.httpStatus);
             // if(clientError.httpStatus === HttpStatusCode.Ref)
             // clientError.message = error.message;
-            if (error.code !== undefined) {
-                //  clientError.code = error.code;
-            }
             if (error.response === undefined) {
                 console.error('Unknown AxiosError error', {
                     error, status: error.status, code: error.code,
@@ -43,15 +39,6 @@ export class ClientError extends Error {
             }
             return clientError;
         }
-        // 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);
         const xError = error;
         if (xError.status !== null && xError.status !== undefined) {
             const statusCode = xError.status;

package/dist/Http/HttpClient.d.ts

@@ -1,6 +1,7 @@
 import { HttpClientRequest } from './HttpClientRequest.js';
 import { HttpClientResponse } from './HttpClientResponse.js';
 export declare class HttpClient {
+    private static readonly axiosInstance;
     static request(request: HttpClientRequest): Promise<HttpClientResponse>;
     private static axiosRequest;
 }

package/dist/Http/HttpClient.js

@@ -2,18 +2,9 @@ import axios from 'axios';
 import { HttpClientResponse } from './HttpClientResponse.js';
 import { ClientError } from './ClientError.js';
 export class HttpClient {
+    static axiosInstance = axios.create();
     static async request(request) {
-        const response = await HttpClient.axiosRequest(request);
-        // 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;
+        return HttpClient.axiosRequest(request);
     }
     static async axiosRequest(request) {
         const requestConfig = {
@@ -24,29 +15,17 @@ export class HttpClient {
         if (request.body !== null && request.body !== undefined) {
             requestConfig.data = request.body;
         }
-        // TODO: should we share this instance between requests?
-        const axiosInstance = axios.create();
-        // TODo: should we catch axios error sand make them into ClientErrors?
         try {
-            const rawResponse = await axiosInstance.request(requestConfig);
+            const rawResponse = await HttpClient.axiosInstance.request(requestConfig);
             const httpResponse = new HttpClientResponse(rawResponse.status, rawResponse.statusText);
             Object.keys(rawResponse.headers).forEach((header) => {
                 const headerValue = rawResponse.headers[header];
                 httpResponse.headers[header] = headerValue === null ? '' : headerValue;
             });
-            httpResponse.body = await rawResponse.data;
+            httpResponse.body = rawResponse.data;
             return httpResponse;
         }
         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);
         }
     }

package/dist/Http/Transport/DirectTransport.d.ts

@@ -0,0 +1,29 @@
+import { Parameters } from '../Data/Parameters.js';
+import { ITransport } from './ITransport.js';
+export interface DirectTransportRoute {
+    prefix: string;
+    baseUrl: string;
+}
+/**
+ * Transport for internal service-to-service calls that bypasses Gateway OAuth.
+ * Authenticates via HMAC-signed session headers instead of an OAuth token.
+ *
+ * Usage:
+ *   const transport = new DirectTransport('http://core-api:5728', process.env.api_secret);
+ *   const client = Client.withTransport(transport);
+ *   client.getFlowEndpoint().getById(id);
+ *
+ * With multiple backends:
+ *   const transport = new DirectTransport('http://core-api:5728', secret, [
+ *     { prefix: '/products', baseUrl: 'http://products-api:5730' },
+ *     { prefix: '/services', baseUrl: 'http://services-api:5731' },
+ *   ]);
+ */
+export declare class DirectTransport implements ITransport {
+    private readonly clients;
+    private readonly sortedRoutes;
+    constructor(defaultBaseUrl: string, apiSecret: string, routes?: DirectTransportRoute[]);
+    request<T>(action: string, parameters?: Parameters, method?: string, _signWithOauthToken?: boolean): Promise<T>;
+    private resolveClient;
+    isDebugEnabled(): boolean;
+}

package/dist/Http/Transport/DirectTransport.js

@@ -0,0 +1,65 @@
+import { createHmac } from 'node:crypto';
+import { OAuthClientOptions } from '../OAuthClientOptions.js';
+import { OAuthClient } from './OAuthClient.js';
+/**
+ * Transport for internal service-to-service calls that bypasses Gateway OAuth.
+ * Authenticates via HMAC-signed session headers instead of an OAuth token.
+ *
+ * Usage:
+ *   const transport = new DirectTransport('http://core-api:5728', process.env.api_secret);
+ *   const client = Client.withTransport(transport);
+ *   client.getFlowEndpoint().getById(id);
+ *
+ * With multiple backends:
+ *   const transport = new DirectTransport('http://core-api:5728', secret, [
+ *     { prefix: '/products', baseUrl: 'http://products-api:5730' },
+ *     { prefix: '/services', baseUrl: 'http://services-api:5731' },
+ *   ]);
+ */
+export class DirectTransport {
+    clients = new Map();
+    sortedRoutes;
+    constructor(defaultBaseUrl, apiSecret, routes = []) {
+        // TODO: do we need to define user, client and ip?
+        const sessionPayload = JSON.stringify({
+            api_version: 'latest',
+            user: null,
+            client: null,
+            ip: 'internal',
+            roles: [],
+            scopes: [],
+            access_token: null,
+        });
+        const sessionSignature = createHmac('sha256', apiSecret).update(sessionPayload).digest('hex');
+        // All routes plus the catch-all default, sorted by prefix length descending (most specific first)
+        this.sortedRoutes = [...routes, { prefix: '', baseUrl: defaultBaseUrl }]
+            .sort((a, b) => b.prefix.length - a.prefix.length);
+        // One OAuthClient per unique base URL with session headers pre-injected
+        const allBaseUrls = new Set([defaultBaseUrl, ...routes.map(r => r.baseUrl)]);
+        for (const baseUrl of allBaseUrls) {
+            const client = new OAuthClient(new OAuthClientOptions(baseUrl));
+            client.addDefaultHeader('x-session', sessionPayload);
+            client.addDefaultHeader('x-session-signature', sessionSignature);
+            this.clients.set(baseUrl, client);
+        }
+    }
+    async request(action, parameters = null, method = 'GET', _signWithOauthToken = true) {
+        const client = this.resolveClient(action);
+        // Always call without OAuth signing — authentication is via the signed session headers
+        return await client.request(action, parameters, method, false);
+    }
+    resolveClient(action) {
+        for (const route of this.sortedRoutes) {
+            if (action.startsWith(route.prefix)) {
+                const client = this.clients.get(route.baseUrl);
+                if (client !== undefined) {
+                    return client;
+                }
+            }
+        }
+        throw new Error('No transport route found for action: ' + action);
+    }
+    isDebugEnabled() {
+        return false;
+    }
+}

package/dist/Http/Transport/ITransport.d.ts

@@ -0,0 +1,5 @@
+import { Parameters } from '../Data/Parameters.js';
+export interface ITransport {
+    request: <T>(action: string, parameters: Parameters, method: string, signWithOauthToken: boolean) => Promise<T>;
+    isDebugEnabled: () => boolean;
+}

package/dist/Http/Transport/ITransport.js

@@ -0,0 +1 @@
+export {};

package/dist/Http/{OAuthClient.d.ts → Transport/OAuthClient.d.ts}

@@ -1,12 +1,13 @@
-import { Headers } from './Data/Headers.js';
-import { Parameters } from './Data/Parameters.js';
-import { OAuthClientOptions } from './OAuthClientOptions.js';
-import { OAuthClientToken } from './OAuthClientToken.js';
-export declare class OAuthClient {
+import { Headers } from '../Data/Headers.js';
+import { Parameters } from '../Data/Parameters.js';
+import { ITransport } from './ITransport.js';
+import { OAuthClientOptions } from '../OAuthClientOptions.js';
+import { OAuthClientToken } from '../OAuthClientToken.js';
+export declare class OAuthClient implements ITransport {
     private readonly options;
     private debug;
     private axiosInstance;
-    private oathClientToken;
+    private oauthClientToken;
     private refreshTokenPromise;
     private version;
     constructor(options: OAuthClientOptions);
@@ -15,7 +16,7 @@ export declare class OAuthClient {
     refreshToken(): Promise<void>;
     private getAxiosInstance;
     isTokenExpires(): boolean;
-    request(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean): Promise<any>;
+    request<T>(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean): Promise<T>;
     isAuthenticated(): boolean;
     getToken(): OAuthClientToken | null;
     setToken(token: OAuthClientToken): void;

package/dist/Http/{OAuthClient.js → Transport/OAuthClient.js}

@@ -1,16 +1,16 @@
 import axios from 'axios';
 import { clientCredentials, ownerCredentials, refreshToken } from 'axios-oauth-client';
-import { JsonSerializable } from '../Model/JsonSerializable.js';
-import { VERSION } from '../version.js';
-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 { ClientError } from '../ClientError.js';
+import { HttpClient } from '../HttpClient.js';
+import { HttpClientRequest } from '../HttpClientRequest.js';
+import { OAuthClientToken } from '../OAuthClientToken.js';
 export class OAuthClient {
     options;
     debug = false;
     axiosInstance = null;
-    oathClientToken = null;
+    oauthClientToken = null;
     refreshTokenPromise = null;
     version = null;
     constructor(options) {
@@ -24,24 +24,15 @@ export class OAuthClient {
                 // 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, this.options.scopes.join(' '));
-                this.oathClientToken = this.tokenToOauthClientToken(rawAuthToken);
+                this.oauthClientToken = this.tokenToOauthClientToken(rawAuthToken);
                 return true;
             }
             if (this.options.clientId !== null && this.options.clientSecret !== null) {
                 // 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('Raw token', rawAuthToken);
-                this.oathClientToken = this.tokenToOauthClientToken(rawAuthToken);
+                this.oauthClientToken = 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 (requestError) {
@@ -55,16 +46,16 @@ export class OAuthClient {
         if (this.debug) {
             console.debug('[OAuthClient] refresh token');
         }
-        if (this.oathClientToken === null) {
+        if (this.oauthClientToken === null) {
             throw new Error('unable to refresh token, auth token not set');
         }
-        if (this.oathClientToken.refresh_token === undefined || this.oathClientToken.refresh_token === null || this.oathClientToken.refresh_token === '') {
+        if (this.oauthClientToken.refresh_token === undefined || this.oauthClientToken.refresh_token === null || this.oauthClientToken.refresh_token === '') {
             throw new Error('unable to refresh token, refresh token not set');
         }
         try {
             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, this.options.scopes.join(' '));
-            this.oathClientToken = this.tokenToOauthClientToken(auth);
+            const auth = await getRefreshToken(this.oauthClientToken.refresh_token, this.options.scopes.join(' '));
+            this.oauthClientToken = this.tokenToOauthClientToken(auth);
         }
         catch (e) {
             throw ClientError.fromError(e);
@@ -82,10 +73,10 @@ export class OAuthClient {
         return this.axiosInstance;
     }
     isTokenExpires() {
-        if (this.oathClientToken === null) {
+        if (this.oauthClientToken === null) {
             throw new Error('No token defined');
         }
-        return OAuthClientToken.isExpired(this.oathClientToken);
+        return OAuthClientToken.isExpired(this.oauthClientToken);
     }
     async request(action, parameters = null, method = 'GET', signWithOauthToken = true) {
         if (signWithOauthToken && !this.isAuthenticated()) {
@@ -93,10 +84,10 @@ export class OAuthClient {
         }
         else {
             if (signWithOauthToken) {
-                if (this.oathClientToken === null) {
+                if (this.oauthClientToken === null) {
                     throw new ClientError('Unable to perform request, access token not provided');
                 }
-                if (signWithOauthToken && OAuthClientToken.isExpired(this.oathClientToken)) {
+                if (signWithOauthToken && OAuthClientToken.isExpired(this.oauthClientToken)) {
                     if (this.refreshTokenPromise === null) {
                         this.refreshTokenPromise = this.refreshToken();
                         await this.refreshTokenPromise;
@@ -113,9 +104,6 @@ export class OAuthClient {
             }
             try {
                 const response = await HttpClient.request(requestData);
-                // if (this.debug) {
-                //     console.info('[Client response] ', {body: response.body});
-                // }
                 return response.body;
             }
             catch (error) {
@@ -135,16 +123,16 @@ export class OAuthClient {
     }
     isAuthenticated() {
         // TODO: other ways to determine if the client is authenticated?
-        return this.oathClientToken !== null && this.oathClientToken !== undefined;
+        return this.oauthClientToken !== null && this.oauthClientToken !== undefined;
     }
     getToken() {
-        return this.oathClientToken;
+        return this.oauthClientToken;
     }
     setToken(token) {
-        this.oathClientToken = token;
+        this.oauthClientToken = token;
     }
     unsetToken() {
-        this.oathClientToken = null;
+        this.oauthClientToken = null;
     }
     enableDebug() {
         this.debug = true;
@@ -229,10 +217,10 @@ export class OAuthClient {
             });
         }
         if (signWithOauthToken) {
-            if (this.oathClientToken === null) {
+            if (this.oauthClientToken === null) {
                 throw new ClientError('Unable to perform request, access token not provided');
             }
-            if (OAuthClientToken.isExpired(this.oathClientToken)) {
+            if (OAuthClientToken.isExpired(this.oauthClientToken)) {
                 throw new Error('Unable to sign request, token is expired');
             }
             requestData = this.signRequest(requestData);
@@ -240,23 +228,16 @@ export class OAuthClient {
         return requestData;
     }
     signRequest(requestObject) {
-        if (this.oathClientToken === null) {
+        if (this.oauthClientToken === 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;
+        const tokenType = this.oauthClientToken.token_type;
+        const accessToken = this.oauthClientToken.access_token;
         if (tokenType !== undefined && tokenType.toLowerCase() === 'bearer') {
             requestObject.setHeader('Authorization', 'Bearer ' + accessToken);
         }
         else {
-            requestObject.addQueryParam('access_token', accessToken);
-            // Attempt to avoid storing the url in proxies, since the access token
-            // is exposed in the query parameters.
-            requestObject.setHeader('Pragma', 'no-store');
-            requestObject.setHeader('Cache-Control', 'no-store');
+            throw new ClientError('Unsupported token type "' + (tokenType ?? 'undefined') + '": only Bearer tokens are supported');
         }
         return requestObject;
     }

package/dist/Service/Endpoint.d.ts

@@ -1,11 +1,11 @@
 import { Parameters } from '../Http/Data/Parameters.js';
 import { QueryString } from '../Http/Data/QueryString.js';
-import { OAuthClient } from '../Http/OAuthClient.js';
+import { ITransport } from '../Http/Transport/ITransport.js';
 import { CollectionResult } from '../Model/Result/CollectionResult.js';
 import { ObjectResult } from '../Model/Result/ObjectResult.js';
 export declare abstract class Endpoint {
-    protected httpClient: OAuthClient;
-    constructor(httpClient: OAuthClient);
+    protected httpClient: ITransport;
+    constructor(httpClient: ITransport);
     private formatParameters;
     private formatKey;
     requestCollection<T>(action: string | QueryString, parser: (input: any) => T, parameters?: Parameters, method?: string, signWithOauthToken?: boolean): Promise<CollectionResult<T>>;

package/dist/Service/Endpoint.js

@@ -3,7 +3,6 @@ import { QueryString } from '../Http/Data/QueryString.js';
 import { HttpStatus } from '../Http/HttpStatus.js';
 import { DataValueCollection } from '../Model/DataValueCollection.js';
 import { ApiError } from '../Model/Error/ApiError.js';
-import { JsonSerializable } from '../Model/JsonSerializable.js';
 import { LogStreamId } from '../Model/Log/LogStreamId.js';
 import { CollectionResult } from '../Model/Result/CollectionResult.js';
 import { ObjectResult } from '../Model/Result/ObjectResult.js';
@@ -32,28 +31,19 @@ export class Endpoint {
         if (Utils.isDate(data)) {
             return data.toISOString();
         }
-        // tODo: this does not seem to work correclty
-        if (data instanceof JsonSerializable && 'jsonSerialize' in data) {
-            return data.jsonSerialize();
-        }
         if (typeof data === 'object') {
-            if (
-            // data instanceof WorkspaceId ||
-            // data instanceof ProjectEnvironmentId ||
-            // data instanceof ProjectId ||
-            // data instanceof OrganisationId ||
-            // data instanceof FlowId ||
-            // data instanceof FlowRunId ||
-            // data instanceof UserId ||
-            // data instanceof DataCollectionResult ||
-            // data instanceof SuccessResult ||
-            data instanceof DataValueCollection
-                || data instanceof LogStreamId) {
+            // These types need recursive formatting applied to their serialized output.
+            if (data instanceof DataValueCollection || data instanceof LogStreamId) {
                 return this.formatParameters(data.jsonSerialize());
             }
             if (data instanceof QueryString) {
                 return data.getParameters();
             }
+            // Duck-type check for JsonSerializable: avoids fragile instanceof checks across
+            // ESM module boundaries where class identity can differ between realms.
+            if (typeof data.jsonSerialize === 'function') {
+                return data.jsonSerialize();
+            }
             const result = {};
             for (const [key, value] of Object.entries(data)) {
                 const formattedKey = this.formatKey(key);
@@ -66,11 +56,14 @@ export class Endpoint {
     formatKey(key) {
         let formattedKey = key.replace(/([A-Z])/g, ' $1');
         formattedKey = formattedKey.split(' ').join('_').toLowerCase();
+        // Intentional: the API expects bare resource names, not ID-suffixed ones.
+        // e.g. TypeScript `environmentId` → snake_case `environment_id` → API param `environment`
         if (formattedKey.endsWith('_id')) {
             formattedKey = formattedKey.substring(0, formattedKey.length - '_id'.length);
         }
+        // Intentional: same convention for plural IDs.
+        // e.g. `categoryIds` → `category_ids` → `categorys` (TODO: handle irregular plurals properly)
         if (formattedKey.endsWith('_ids')) {
-            // TODO: update this to format correct plurals (for example category_ids should become categories instead of categorys)
             formattedKey = formattedKey.substring(0, formattedKey.length - '_ids'.length) + 's';
         }
         return formattedKey;
@@ -88,10 +81,6 @@ export class Endpoint {
             throw this.toApiError(error);
         }
         const result = new CollectionResult();
-        /**
-         * Parse errors
-         */
-        // DataResult.appendErrors(result, requestResponse);
         /**
          * Parse data
          */
@@ -125,11 +114,6 @@ export class Endpoint {
             }
             throw this.toApiError(error);
         }
-        // TODO: add errors
-        /**
-         * Parse errors
-         */
-        // TODO: temporary check until we know the API is fully upgraded
         if (requestResponse === null || requestResponse === undefined) {
             throw new ApiError('Unable to parse object: response is empty for action `[' + method + '] ' + action + '`', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
         }
@@ -146,7 +130,6 @@ export class Endpoint {
             if (error.response !== null && error.response !== undefined) {
                 const response = error.response;
                 if (response.data.error !== undefined) {
-                    // console.debug('Error data', errorData);
                     if (response.data.error.type !== undefined) {
                         apiError.type = response.data.error.type;
                     }
@@ -163,15 +146,11 @@ export class Endpoint {
             }
             return apiError;
         }
-        // TODO: remove this
-        console.log('Not client error', { error });
+        if (this.httpClient.isDebugEnabled()) {
+            console.error('Unrecognised error type (not a ClientError)', { error });
+        }
         return new ApiError('Unknown Error', HttpStatus.HTTP_INTERNAL_SERVER_ERROR);
     }
-    // public async request<T>(action: string, parameters: any | null = null, method: string = 'GET', signWithOauthToken: boolean = true): Promise<DataResult<T>> {
-    //     const result: any = await this.httpClient.request(action, parameters, method, signWithOauthToken);
-    //
-    //     return DataResult.parse<T>(result);
-    // }
     parseCollection(rawData, parser) {
         const data = [];
         if (!Array.isArray(rawData)) {
@@ -186,7 +165,6 @@ export class Endpoint {
         return data;
     }
     parseObject(rawObject, parser) {
-        // TODO: is it interesting to keep this wrapper, or only in develop mode?
         const wrappedData = ObjectWrapper.wrap(rawObject);
         try {
             return parser(wrappedData);

package/dist/Service/FlowEndpoint.d.ts

@@ -1,12 +1,12 @@
 import { Flow } from '../Model/Flow/Flow.js';
 import { FlowSummary } from '../Model/Flow/FlowSummary.js';
-import { CollectionResult } from '../Model/Result/CollectionResult.js';
 import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
 import { Endpoint } from './Endpoint.js';
 export declare class FlowEndpoint extends Endpoint {
     getByProject(projectId: string, pagination: CursorPagination): Promise<CollectionResult<Flow>>;
     getById(flowId: string): Promise<Flow | null>;
-    getFlowSummaries(projectId: string, projectEnvironmentId?: string | null): Promise<CollectionResult<FlowSummary>>;
+    getFlowSummaries(projectId: string, projectEnvironmentId?: string | null, pagination?: CursorPagination | null): Promise<CollectionResult<FlowSummary>>;
     getFlowSummary(flowId: string, projectEnvironmentId?: string | null): Promise<FlowSummary | null>;
     save(flow: Flow): Promise<Flow>;
 }

package/dist/Service/FlowEndpoint.js

@@ -1,8 +1,8 @@
-import { Utils } from '../Utils.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { HttpStatus } from '../Http/HttpStatus.js';
 import { Flow } from '../Model/Flow/Flow.js';
 import { FlowSummary } from '../Model/Flow/FlowSummary.js';
-import { HttpStatus } from '../Http/HttpStatus.js';
-import { QueryString } from '../Http/Data/QueryString.js';
+import { Utils } from '../Utils.js';
 import { Endpoint } from './Endpoint.js';
 export class FlowEndpoint extends Endpoint {
     async getByProject(projectId, pagination) {
@@ -34,22 +34,16 @@ export class FlowEndpoint extends Endpoint {
             throw error;
         }
     }
-    async getFlowSummaries(projectId, projectEnvironmentId = null) {
+    async getFlowSummaries(projectId, projectEnvironmentId = null, pagination = null) {
         let parameters = null;
         if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
             parameters = { environment: projectEnvironmentId };
         }
-        const result = await this.requestCollection('projects/' + projectId + '/flowsummaries', FlowSummary.parse, parameters);
-        return result;
-        //
-        //     }).catch((reason: any) => {
-        //         if (this.httpClient.isDebugEnabled()) {
-        //             console.error('Failed to load flow summaries: ' + reason);
-        //         }
-        //
-        //         reject(reason);
-        //     });
-        // });
+        const queryString = new QueryString('projects/' + projectId + '/flowsummaries');
+        if (pagination !== null) {
+            queryString.addPagination(pagination);
+        }
+        return await this.requestCollection(queryString, FlowSummary.parse, parameters);
     }
     async getFlowSummary(flowId, projectEnvironmentId = null) {
         let parameters = null;

package/dist/Service/ProviderTokenEndpoint.d.ts

@@ -4,4 +4,5 @@ import { Endpoint } from './Endpoint.js';
 export declare class ProviderTokenEndpoint extends Endpoint {
     getProviderToken(providerTokenId: string): Promise<ProviderToken | null>;
     getProviderTokenAccessToken(providerTokenId: string): Promise<ProviderTokenAccessToken | null>;
+    revokeProviderToken(providerTokenId: string): Promise<boolean>;
 }

package/dist/Service/ProviderTokenEndpoint.js

@@ -13,4 +13,22 @@ export class ProviderTokenEndpoint extends Endpoint {
         const result = await this.requestObject(queryString, null, ProviderTokenAccessToken.parse);
         return result.getData();
     }
+    async revokeProviderToken(providerTokenId) {
+        const queryString = new QueryString('/provider-tokens/' + providerTokenId);
+        try {
+            const parser = (raw) => ({ deleted: raw.deleted });
+            const result = await this.requestObject(queryString, null, parser, 'DELETE');
+            const re = result.getData();
+            if (re === null) {
+                throw new Error('Unable to revoke provider token: wrong response from API');
+            }
+            return re.deleted;
+        }
+        catch (e) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to revoke provider token: ', e);
+            }
+            throw e;
+        }
+    }
 }

package/dist/Service/StorageEndpoint.js

@@ -32,7 +32,6 @@ export class StorageEndpoint extends Endpoint {
             const result = await this.requestObject(cmd, null, parser, 'DELETE');
             const re = result.getData();
             if (re === null) {
-                console.log('clearpool wrong data', { result, parsed: re });
                 throw new Error('Unable to clear storage pool: wrong response from API');
             }
             return re.deleted;
@@ -90,7 +89,6 @@ export class StorageEndpoint extends Endpoint {
             const result = await this.requestObject(cmd, storageItem, StorageItem.parse, 'POST');
             const savedItem = result.getData();
             if (savedItem === null) {
-                console.log('Storage set item wrong data', { result, parsed: savedItem });
                 throw new Error('Unable to save storage item: wrong response from API');
             }
             return savedItem;
@@ -109,7 +107,6 @@ export class StorageEndpoint extends Endpoint {
             const result = await this.requestObject(cmd, null, parser, 'DELETE');
             const x = result.getData();
             if (x === null) {
-                console.log('Storage delete item wrong data', { result, parsed: x });
                 throw new Error('Unable to delete storage item: wrong response from API');
             }
             return x.deleted;

package/dist/Service/UserEndpoint.js

@@ -16,7 +16,6 @@ export class UserEndpoint extends Endpoint {
             const result = await this.requestObject('/users/auth/providers', { provider: providerId }, parser, 'DELETE');
             const re = result.getData();
             if (re === null) {
-                console.log('remove auth provider wrong data', { result, parsed: re });
                 throw new Error('Unable to remove auth provider: wrong response from API');
             }
             return re.deleted;
@@ -59,9 +58,7 @@ export class UserEndpoint extends Endpoint {
     async create(user, password, invitationCode = null) {
         try {
             const url = '/users/';
-            const data = user;
-            data.password = password;
-            data.invitation_code = invitationCode;
+            const data = { ...user, password, invitation_code: invitationCode };
             const result = await this.requestObject(url, data, User.parse, 'PUT', false);
             const createdUser = result.getData();
             if (createdUser === null) {
@@ -83,7 +80,6 @@ export class UserEndpoint extends Endpoint {
             const result = await this.requestObject(url, { email }, parser, 'POST', false);
             const re = result.getData();
             if (re === null) {
-                console.log('reset password request wrong data', { result, parsed: re });
                 throw new Error('Unable to request password reset: wrong response from API');
             }
             return re.requested;
@@ -102,7 +98,6 @@ export class UserEndpoint extends Endpoint {
             const result = await this.requestObject(url, { password }, parser, 'POST', false);
             const re = result.getData();
             if (re === null) {
-                console.log('reset password wrong data', { result, parsed: re });
                 throw new Error('Unable to reset password: wrong response from API');
             }
             return re.updated;
@@ -128,7 +123,6 @@ export class UserEndpoint extends Endpoint {
             const result = await this.requestObject(url, data, parser, 'POST', true);
             const re = result.getData();
             if (re === null) {
-                console.log('created web push wrong data', { result, parsed: re });
                 throw new Error('Unable to request web push: wrong response from API');
             }
             return re.created;

package/dist/index.d.ts

@@ -7,7 +7,10 @@ export { QueryString } from './Http/Data/QueryString.js';
 export { HttpClient } from './Http/HttpClient.js';
 export { HttpClientRequest } from './Http/HttpClientRequest.js';
 export { HttpClientResponse } from './Http/HttpClientResponse.js';
-export { OAuthClient } from './Http/OAuthClient.js';
+export { ITransport } from './Http/Transport/ITransport.js';
+export { DirectTransport } from './Http/Transport/DirectTransport.js';
+export type { DirectTransportRoute } from './Http/Transport/DirectTransport.js';
+export { OAuthClient } from './Http/Transport/OAuthClient.js';
 export { OAuthClientOptions } from './Http/OAuthClientOptions.js';
 export { OAuthClientToken } from './Http/OAuthClientToken.js';
 export { ClientError } from './Http/ClientError.js';

package/dist/index.js

@@ -2,7 +2,8 @@ export { QueryString } from './Http/Data/QueryString.js';
 export { HttpClient } from './Http/HttpClient.js';
 export { HttpClientRequest } from './Http/HttpClientRequest.js';
 export { HttpClientResponse } from './Http/HttpClientResponse.js';
-export { OAuthClient } from './Http/OAuthClient.js';
+export { DirectTransport } from './Http/Transport/DirectTransport.js';
+export { OAuthClient } from './Http/Transport/OAuthClient.js';
 export { OAuthClientOptions } from './Http/OAuthClientOptions.js';
 export { OAuthClientToken } from './Http/OAuthClientToken.js';
 export { ClientError } from './Http/ClientError.js';

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.47.1";
+export declare const VERSION = "1.48.1";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = "1.47.1";
+export const VERSION = "1.48.1";

package/package.json

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