@attlaz/client 1.77.1

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/Data/Headers.d.ts

@@ -0,0 +1,3 @@
+export type Headers = {
+    [key: string]: string | string[];
+};

package/dist/Http/Data/Headers.js

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

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

@@ -0,0 +1,3 @@
+export type Parameters = {
+    [key: string]: string | number;
+} | object | null;

package/dist/Http/Data/Parameters.js

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

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

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

package/dist/Http/Data/QueryString.js

@@ -0,0 +1,67 @@
+export class QueryString {
+    command;
+    parameters = [];
+    constructor(command = '') {
+        this.command = command;
+    }
+    setCommand(command) {
+        this.command = command;
+    }
+    set(parameter, value) {
+        const existingParam = this.parameters.find((param) => param.parameter === parameter);
+        if (existingParam !== undefined) {
+            throw new Error('Param already defined');
+        }
+        this.parameters.push({ parameter, value });
+    }
+    addPagination(pagination) {
+        if (pagination !== null && pagination !== undefined) {
+            if (pagination.limit !== null && pagination.limit !== undefined) {
+                this.set('limit', pagination.limit);
+            }
+            if (pagination.startingAfter !== null && pagination.startingAfter !== undefined && pagination.startingAfter !== '') {
+                this.set('starting_after', pagination.startingAfter);
+            }
+            if (pagination.endingBefore !== null && pagination.endingBefore !== undefined && pagination.endingBefore !== '') {
+                this.set('ending_before', pagination.endingBefore);
+            }
+        }
+    }
+    addFilters(filters) {
+        for (const filter of filters.toArray()) {
+            const strMethod = filter.method === 'eq' ? '' : '[' + filter.method + ']';
+            this.set(filter.field + strMethod, filter.value);
+        }
+    }
+    addStateFilter(states) {
+        if (states !== null) {
+            this.set('state', states);
+        }
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    build() {
+        if (this.parameters.length === 0) {
+            return this.command;
+        }
+        const output = [];
+        for (const parameter of this.parameters) {
+            const { value } = parameter;
+            if (Array.isArray(value)) {
+                /** Legacy way **/
+                //    output.push(parameter.parameter + '=' + encodeURIComponent(value.join(',')));
+                for (const subValue of value) {
+                    output.push(parameter.parameter + '=' + encodeURIComponent(subValue));
+                }
+            }
+            else {
+                output.push(parameter.parameter + '=' + encodeURIComponent(value));
+            }
+        }
+        if (this.command.includes('?')) {
+            return this.command + '&' + output.join('&');
+        }
+        return this.command + '?' + output.join('&');
+    }
+}

package/dist/Http/HttpClient.d.ts

@@ -0,0 +1,5 @@
+import { HttpClientRequest } from './HttpClientRequest.js';
+import { HttpClientResponse } from './HttpClientResponse.js';
+export declare class HttpClient {
+    static request(request: HttpClientRequest): Promise<HttpClientResponse>;
+}

package/dist/Http/HttpClient.js

@@ -0,0 +1,54 @@
+import { HttpClientResponse } from './HttpClientResponse.js';
+import { ClientError } from './ClientError.js';
+export class HttpClient {
+    static async request(request) {
+        const init = {
+            method: request.method,
+            headers: request.headers,
+        };
+        // Node's fetch (undici) throws TypeError when GET/HEAD carry a body. Axios used to silently drop it,
+        // so callers may still set body on GET — skip it here instead of propagating a confusing network error.
+        const method = request.method.toUpperCase();
+        if (request.body !== null && request.body !== undefined && method !== 'GET' && method !== 'HEAD') {
+            init.body = request.body;
+        }
+        try {
+            const rawResponse = await fetch(request.getFullUrl(), init);
+            if (!rawResponse.ok) {
+                const statusText = rawResponse.statusText || 'Unknown error';
+                const clientError = ClientError.byStatus(rawResponse.status, statusText)
+                    ?? new ClientError(statusText, rawResponse.status);
+                // Try to attach the response body for downstream error handling
+                try {
+                    clientError.response = {
+                        status: rawResponse.status,
+                        statusText,
+                        data: await rawResponse.json(),
+                    };
+                }
+                catch {
+                    // Response body is not JSON — leave response as-is
+                }
+                throw clientError;
+            }
+            const httpResponse = new HttpClientResponse(rawResponse.status, rawResponse.statusText);
+            rawResponse.headers.forEach((value, header) => {
+                httpResponse.headers[header] = value;
+            });
+            const contentType = rawResponse.headers.get('content-type');
+            if (contentType !== null && contentType.includes('application/json')) {
+                httpResponse.body = await rawResponse.json();
+            }
+            else {
+                httpResponse.body = await rawResponse.text();
+            }
+            return httpResponse;
+        }
+        catch (error) {
+            if (error instanceof ClientError) {
+                throw error;
+            }
+            throw ClientError.fromError(error);
+        }
+    }
+}

package/dist/Http/HttpClientRequest.d.ts

@@ -0,0 +1,17 @@
+import { Headers } from './Data/Headers.js';
+export declare class HttpClientRequest {
+    static readonly GET: string;
+    static readonly POST: string;
+    static readonly PUT: string;
+    method: string;
+    headers: Headers;
+    body: any;
+    private urlObj;
+    constructor(url: string, method?: string);
+    setJsonHeader(): void;
+    setBasicAuth(user: string, password: string): void;
+    setHeader(key: string, value: string): void;
+    addQueryParam(key: string, value: string | number): void;
+    setJsonBody(data: any): void;
+    getFullUrl(): string;
+}

package/dist/Http/HttpClientRequest.js

@@ -0,0 +1,39 @@
+import { Utils } from '../Utils.js';
+import { JsonSerializable } from '../Model/JsonSerializable.js';
+export class HttpClientRequest {
+    static GET = 'GET';
+    static POST = 'POST';
+    static PUT = 'PUT';
+    method;
+    headers = {};
+    body = null;
+    urlObj;
+    constructor(url, method = HttpClientRequest.GET) {
+        this.urlObj = new URL(url);
+        this.method = method;
+    }
+    setJsonHeader() {
+        this.setHeader('Content-Type', 'application/json');
+    }
+    setBasicAuth(user, password) {
+        this.setHeader('Authorization', 'Basic ' + Utils.base64encode(user + ':' + password));
+    }
+    setHeader(key, value) {
+        this.headers[key] = value;
+    }
+    addQueryParam(key, value) {
+        this.urlObj.searchParams.append(key, value.toString());
+    }
+    setJsonBody(data) {
+        this.setJsonHeader();
+        this.body = JsonSerializable.stringify(data);
+    }
+    getFullUrl() {
+        let result = this.urlObj.href;
+        // Remove trailing slash
+        result = result.replace(/\/$/, '');
+        // Remove slash in query
+        result = result.replace('/?', '?');
+        return result;
+    }
+}

package/dist/Http/HttpClientResponse.d.ts

@@ -0,0 +1,8 @@
+import { Headers } from './Data/Headers.js';
+export declare class HttpClientResponse {
+    status: number;
+    statusText: string;
+    body: any | null;
+    headers: Headers;
+    constructor(status: number, statusText: string);
+}

package/dist/Http/HttpClientResponse.js

@@ -0,0 +1,10 @@
+export class HttpClientResponse {
+    status;
+    statusText;
+    body = null;
+    headers = {};
+    constructor(status, statusText) {
+        this.status = status;
+        this.statusText = statusText;
+    }
+}

package/dist/Http/HttpStatus.d.ts

@@ -0,0 +1,13 @@
+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_REQUEST_ENTITY_TOO_LARGE: 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,13 @@
+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_REQUEST_ENTITY_TOO_LARGE = 413;
+    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/OAuthClientOptions.d.ts

@@ -0,0 +1,11 @@
+export declare class OAuthClientOptions {
+    apiEndpoint: string;
+    readonly clientId: string | null;
+    readonly clientSecret: string | null;
+    accessTokenUri: string;
+    authorizationUri: string;
+    redirectUri: string;
+    scopes: string[];
+    state: string;
+    constructor(apiEndpoint: string, clientId?: string | null, clientSecret?: string | null);
+}

package/dist/Http/OAuthClientOptions.js

@@ -0,0 +1,15 @@
+export class OAuthClientOptions {
+    apiEndpoint;
+    clientId;
+    clientSecret;
+    accessTokenUri = 'oauth/token';
+    authorizationUri = 'oauth/authorize';
+    redirectUri = 'https://example.com/auth/github/callback';
+    scopes = [];
+    state = '';
+    constructor(apiEndpoint, clientId = null, clientSecret = null) {
+        this.apiEndpoint = apiEndpoint;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+    }
+}

package/dist/Http/OAuthClientToken.d.ts

@@ -0,0 +1,11 @@
+export declare class OAuthClientToken {
+    access_token: string;
+    token_type: string;
+    refresh_token: string | null;
+    expires: Date | null;
+    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/dist/Http/OAuthClientToken.js

@@ -0,0 +1,32 @@
+export class OAuthClientToken {
+    access_token = '';
+    token_type = '';
+    refresh_token = null;
+    expires = null;
+    scope = '';
+    constructor(access_token, token_type, refresh_token, scope) {
+        this.access_token = access_token;
+        this.token_type = token_type;
+        this.refresh_token = refresh_token;
+        this.scope = scope;
+    }
+    static isExpired(token) {
+        if (token.expires === null) {
+            return false;
+        }
+        return token.expires <= new Date();
+    }
+    static serialize(token) {
+        return JSON.stringify(token);
+    }
+    static deserialize(serializedToken) {
+        const token = JSON.parse(serializedToken);
+        if (token.expires !== null && token.expires !== undefined) {
+            token.expires = new Date(token.expires);
+        }
+        else {
+            token.expires = null;
+        }
+        return token;
+    }
+}

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

@@ -0,0 +1,41 @@
+import { Parameters } from '../Data/Parameters.js';
+import { ITransport, ParseErrorHandler } 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.
+ *
+ * The caller is responsible for computing the HMAC signature (since this requires
+ * node:crypto which is not available in browser environments).
+ *
+ * Usage:
+ *   import {createHmac} from 'node:crypto';
+ *   const sessionPayload = DirectTransport.createSessionPayload();
+ *   const sessionSignature = createHmac('sha256', apiSecret).update(sessionPayload).digest('hex');
+ *   const transport = new DirectTransport('http://core-api:5728', sessionPayload, sessionSignature);
+ *   const client = Client.withTransport(transport);
+ *
+ * With multiple backends:
+ *   const transport = new DirectTransport('http://core-api:5728', sessionPayload, sessionSignature, [
+ *     { 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;
+    private parseErrorHandler;
+    /**
+     * Creates the default session payload for internal service-to-service calls.
+     */
+    static createSessionPayload(): string;
+    constructor(defaultBaseUrl: string, sessionPayload: string, sessionSignature: string, routes?: DirectTransportRoute[]);
+    request<T>(action: string, parameters?: Parameters, method?: string, _signWithOauthToken?: boolean): Promise<T>;
+    private resolveClient;
+    isDebugEnabled(): boolean;
+    setParseErrorHandler(handler: ParseErrorHandler | null): void;
+    reportParseError(message: string, context: Record<string, unknown>): void;
+}

package/dist/Http/Transport/DirectTransport.js

@@ -0,0 +1,83 @@
+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.
+ *
+ * The caller is responsible for computing the HMAC signature (since this requires
+ * node:crypto which is not available in browser environments).
+ *
+ * Usage:
+ *   import {createHmac} from 'node:crypto';
+ *   const sessionPayload = DirectTransport.createSessionPayload();
+ *   const sessionSignature = createHmac('sha256', apiSecret).update(sessionPayload).digest('hex');
+ *   const transport = new DirectTransport('http://core-api:5728', sessionPayload, sessionSignature);
+ *   const client = Client.withTransport(transport);
+ *
+ * With multiple backends:
+ *   const transport = new DirectTransport('http://core-api:5728', sessionPayload, sessionSignature, [
+ *     { prefix: '/products', baseUrl: 'http://products-api:5730' },
+ *     { prefix: '/services', baseUrl: 'http://services-api:5731' },
+ *   ]);
+ */
+export class DirectTransport {
+    clients = new Map();
+    sortedRoutes;
+    parseErrorHandler = null;
+    /**
+     * Creates the default session payload for internal service-to-service calls.
+     */
+    static createSessionPayload() {
+        return JSON.stringify({
+            api_version: 'latest',
+            user: null,
+            client: null,
+            ip: 'internal',
+            roles: [],
+            scopes: [],
+            access_token: null,
+        });
+    }
+    constructor(defaultBaseUrl, sessionPayload, sessionSignature, routes = []) {
+        // 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;
+    }
+    setParseErrorHandler(handler) {
+        this.parseErrorHandler = handler;
+    }
+    reportParseError(message, context) {
+        if (this.parseErrorHandler !== null) {
+            this.parseErrorHandler(message, context);
+            return;
+        }
+        console.error(message, context);
+    }
+}

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

@@ -0,0 +1,13 @@
+import { Parameters } from '../Data/Parameters.js';
+/**
+ * Invoked when an endpoint fails to parse a response object (schema drift). Reporting is
+ * non-fatal — parsing still degrades gracefully. Defaults to console.error; set a custom handler
+ * (e.g. via Client.setParseErrorHandler) to route these to a logger / error tracker.
+ */
+export type ParseErrorHandler = (message: string, context: Record<string, unknown>) => void;
+export interface ITransport {
+    request: <T>(action: string, parameters: Parameters, method: string, signWithOauthToken: boolean) => Promise<T>;
+    isDebugEnabled: () => boolean;
+    reportParseError: (message: string, context: Record<string, unknown>) => void;
+    setParseErrorHandler: (handler: ParseErrorHandler | null) => void;
+}

package/dist/Http/Transport/ITransport.js

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

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

@@ -0,0 +1,45 @@
+import { Headers } from '../Data/Headers.js';
+import { Parameters } from '../Data/Parameters.js';
+import { OAuthClientOptions } from '../OAuthClientOptions.js';
+import { OAuthClientToken } from '../OAuthClientToken.js';
+import { ITransport, ParseErrorHandler } from './ITransport.js';
+export declare class OAuthClient implements ITransport {
+    private readonly options;
+    private debug;
+    private oauthClientToken;
+    private refreshTokenPromise;
+    private version;
+    private parseErrorHandler;
+    constructor(options: OAuthClientOptions);
+    authenticate(username: string, password: string): Promise<boolean>;
+    authenticate(): Promise<boolean>;
+    refreshToken(): Promise<void>;
+    private isPublicClient;
+    /**
+     * Performs an OAuth token request (password, client_credentials or refresh_token grant) and
+     * returns the raw token response. On a non-ok response it throws a ClientError carrying the
+     * server's HTTP status and, when the body is JSON, its structured error message.
+     */
+    private requestToken;
+    isTokenExpired(): boolean;
+    request<T>(action: string, parameters?: Parameters, method?: string, signWithOauthToken?: boolean): Promise<T>;
+    isAuthenticated(): boolean;
+    getToken(): OAuthClientToken | null;
+    setToken(token: OAuthClientToken): void;
+    unsetToken(): void;
+    enableDebug(): void;
+    disableDebug(): void;
+    isDebugEnabled(): boolean;
+    setParseErrorHandler(handler: ParseErrorHandler | null): void;
+    reportParseError(message: string, context: Record<string, unknown>): void;
+    private defaultHeaders;
+    getDefaultHeaders(): Headers;
+    private initDefaultHeaders;
+    addDefaultHeader(header: string, value: string): void;
+    setVersion(version: string | null): void;
+    private isNodeEnvironment;
+    private tokenToOauthClientToken;
+    private getApiEndpointUrl;
+    private createRequestData;
+    private signRequest;
+}