@attlaz/client 1.77.1

package/dist/Service/ChannelEndpoint.js

@@ -0,0 +1,96 @@
+import { Channel } from '../Model/Messaging/Channel/Channel.js';
+import { ChannelHistory } from '../Model/Messaging/ChannelHistory.js';
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Endpoint } from './Endpoint.js';
+export class ChannelEndpoint extends Endpoint {
+    async getById(channelId) {
+        try {
+            const result = await this.requestObject('/channels/' + channelId + '', null, Channel.parse);
+            return result.getData();
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load channels by id "' + channelId + '": ', ex);
+            }
+            throw ex;
+        }
+    }
+    async getByWorkspace(workspaceId, pagination = null) {
+        try {
+            const queryString = new QueryString('/workspaces/' + workspaceId + '/channels');
+            queryString.addPagination(pagination);
+            const result = await this.requestCollection(queryString, Channel.parse);
+            return result;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load channels for workspace "' + workspaceId + '": ', ex);
+            }
+            throw ex;
+        }
+    }
+    async getByOwner(pagination = null) {
+        try {
+            const queryString = new QueryString('channels');
+            queryString.addPagination(pagination);
+            const result = await this.requestCollection(queryString, Channel.parse);
+            return result;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load channels for current user: ', ex);
+            }
+            throw ex;
+        }
+    }
+    async getMessages(channelId, pagination = null) {
+        try {
+            const querystring = new QueryString('/channels/' + channelId + '/messages');
+            querystring.addPagination(pagination);
+            const result = await this.requestCollection(querystring, ChannelHistory.parse);
+            return result;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load channels history: ', ex);
+            }
+            throw ex;
+        }
+    }
+    async save(subscriberChannel) {
+        try {
+            const url = '/channels/';
+            const result = await this.requestObject(url, subscriberChannel, Channel.parse, 'POST');
+            const updatedChannel = result.getData();
+            if (updatedChannel === null) {
+                throw new Error('Unable to update channel: wrong response from API');
+            }
+            return updatedChannel;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save channel: ', ex);
+            }
+            throw ex;
+        }
+    }
+    async testChannel(subscriberChannel) {
+        try {
+            const url = '/channels/' + subscriberChannel.id + '/test';
+            const parser = (raw) => ({ tested: raw.tested });
+            const result = await this.requestObject(url, {}, parser, 'POST');
+            const re = result.getData();
+            if (re === null) {
+                console.log('testChannel wrong data', { result, parsed: re });
+                throw new Error('Unable to test channel: wrong response from API');
+            }
+            return re.tested;
+        }
+        catch (ex) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to test channel: ', ex);
+            }
+            throw ex;
+        }
+    }
+}

package/dist/Service/CodeDeployEndpoint.d.ts

@@ -0,0 +1,9 @@
+import { CodeDeploy } from '../Model/Project/CodeDeploy.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class CodeDeployEndpoint extends Endpoint {
+    getById(deployId: string): Promise<CodeDeploy | null>;
+    getLatestDeploy(codeSourceId: string): Promise<CodeDeploy | null>;
+    getByCodeSource(codeSourceId: string): Promise<CollectionResult<CodeDeploy>>;
+    requestDeploy(codeSourceId: string): Promise<CodeDeploy>;
+}

package/dist/Service/CodeDeployEndpoint.js

@@ -0,0 +1,56 @@
+import { CodeDeploy } from '../Model/Project/CodeDeploy.js';
+import { Endpoint } from './Endpoint.js';
+export class CodeDeployEndpoint extends Endpoint {
+    async getById(deployId) {
+        try {
+            const rawDeploy = await this.requestObject('/deploys/' + deployId, null, CodeDeploy.parse);
+            return rawDeploy.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load deploy by id', error);
+            }
+            throw error;
+        }
+    }
+    async getLatestDeploy(codeSourceId) {
+        try {
+            const rawDeploy = await this.requestObject('/codesources/' + codeSourceId + '/latestdeploy', null, CodeDeploy.parse);
+            return rawDeploy.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load latest deploy by code source', error);
+            }
+            throw error;
+        }
+    }
+    async getByCodeSource(codeSourceId) {
+        try {
+            const rawDeploys = await this.requestCollection('/codesources/' + codeSourceId + '/deploys', CodeDeploy.parse);
+            return rawDeploys;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load deploys by code source', error);
+            }
+            throw error;
+        }
+    }
+    async requestDeploy(codeSourceId) {
+        try {
+            const result = await this.requestObject('/codesources/' + codeSourceId + '/deploys', null, CodeDeploy.parse, 'POST');
+            const requestedDeploy = result.getData();
+            if (requestedDeploy === null) {
+                throw new Error('Deploy not requested');
+            }
+            return requestedDeploy;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to request deploy', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/CodeSourceStrategiesEndpoint.d.ts

@@ -0,0 +1,8 @@
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CodeSourceBuildStrategy } from '../Model/Deployment/CodeSourceBuildStrategy.js';
+import { CodeSourceRunStrategy } from '../Model/Deployment/CodeSourceRunStrategy.js';
+import { Endpoint } from './Endpoint.js';
+export declare class CodeSourceStrategiesEndpoint extends Endpoint {
+    getAllBuildStrategies(workspaceId: string): Promise<CollectionResult<CodeSourceBuildStrategy>>;
+    getAllRunStrategies(workspaceId: string): Promise<CollectionResult<CodeSourceRunStrategy>>;
+}

package/dist/Service/CodeSourceStrategiesEndpoint.js

@@ -0,0 +1,13 @@
+import { CodeSourceBuildStrategy } from '../Model/Deployment/CodeSourceBuildStrategy.js';
+import { CodeSourceRunStrategy } from '../Model/Deployment/CodeSourceRunStrategy.js';
+import { Endpoint } from './Endpoint.js';
+export class CodeSourceStrategiesEndpoint extends Endpoint {
+    async getAllBuildStrategies(workspaceId) {
+        const cmd = '/workspaces/' + workspaceId + '/codesources/buildstrategies';
+        return await this.requestCollection(cmd, CodeSourceBuildStrategy.parse);
+    }
+    async getAllRunStrategies(workspaceId) {
+        const cmd = '/workspaces/' + workspaceId + '/codesources/runstrategies';
+        return await this.requestCollection(cmd, CodeSourceRunStrategy.parse);
+    }
+}

package/dist/Service/CollectionsEndpoint.d.ts

@@ -0,0 +1,11 @@
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { Collection } from '../Model/Collections/Collection.js';
+import { Endpoint } from './Endpoint.js';
+import { CollectionRecord } from '../Model/Collections/CollectionRecord.js';
+export declare class CollectionsEndpoint extends Endpoint {
+    getAll(projectId: string, pagination: CursorPagination): Promise<CollectionResult<Collection>>;
+    getById(collectionId: string): Promise<Collection | null>;
+    getRecords(collectionId: string, pagination: CursorPagination): Promise<CollectionResult<CollectionRecord>>;
+    addRecord(collectionId: string, properties: unknown): Promise<CollectionRecord>;
+}

package/dist/Service/CollectionsEndpoint.js

@@ -0,0 +1,54 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Collection } from '../Model/Collections/Collection.js';
+import { Endpoint } from './Endpoint.js';
+import { CollectionRecord } from '../Model/Collections/CollectionRecord.js';
+export class CollectionsEndpoint extends Endpoint {
+    async getAll(projectId, pagination) {
+        const qs = new QueryString('/projects/' + projectId + '/collections');
+        qs.addPagination(pagination);
+        return await this.requestCollection(qs, Collection.parse);
+    }
+    async getById(collectionId) {
+        try {
+            const qs = new QueryString('/collections/' + collectionId + '');
+            const result = await this.requestObject(qs, null, Collection.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load Collection by id: ', error);
+            }
+            throw error;
+        }
+    }
+    async getRecords(collectionId, pagination) {
+        try {
+            const qs = new QueryString('/collections/' + collectionId + '/records');
+            qs.addPagination(pagination);
+            return await this.requestCollection(qs, CollectionRecord.parse);
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load Collection by id: ', error);
+            }
+            throw error;
+        }
+    }
+    async addRecord(collectionId, properties) {
+        try {
+            const qs = new QueryString('/collections/' + collectionId + '');
+            const result = await this.requestObject(qs, { properties }, CollectionRecord.parse, 'POST');
+            const updatedWorkspace = result.getData();
+            if (updatedWorkspace === null) {
+                throw new Error('CollectionRecord not created');
+            }
+            return updatedWorkspace;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save CollectionRecord: ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/CommandExecutionEndpoint.d.ts

@@ -0,0 +1,14 @@
+import { CommandExecutionFilter } from '../Model/Command/CommandExecutionFilter.js';
+import { CommandExecutionHistory } from '../Model/Command/CommandExecutionHistory.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { UserSummary } from '../Model/User/UserSummary.js';
+import { Endpoint } from './Endpoint.js';
+export declare class CommandExecutionEndpoint extends Endpoint {
+    getAll(pagination?: CursorPagination | null, filter?: CommandExecutionFilter | null): Promise<CollectionResult<CommandExecutionHistory>>;
+    getById(id: string): Promise<CommandExecutionHistory | null>;
+    /** Distinct users that requested commands, resolved to display-safe summaries (for the requester filter). */
+    getDistinctRequesters(): Promise<UserSummary[]>;
+    private static parseSummary;
+    private static parse;
+}

package/dist/Service/CommandExecutionEndpoint.js

@@ -0,0 +1,60 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { CommandExecutionHistory } from '../Model/Command/CommandExecutionHistory.js';
+import { CommandExecutionStatus } from '../Model/Command/CommandExecutionStatus.js';
+import { DataValueCollection } from '../Model/DataValueCollection.js';
+import { State } from '../Model/State.js';
+import { UserSummary } from '../Model/User/UserSummary.js';
+import { Utils } from '../Utils.js';
+import { Endpoint } from './Endpoint.js';
+export class CommandExecutionEndpoint extends Endpoint {
+    async getAll(pagination = null, filter = null) {
+        const queryString = new QueryString('/system/command-executions');
+        queryString.addPagination(pagination);
+        if (filter !== null) {
+            if (filter.status !== undefined && filter.status.length > 0) {
+                queryString.set('status', filter.status);
+            }
+            if (filter.type !== undefined && filter.type.length > 0) {
+                queryString.set('type', filter.type);
+            }
+            if (filter.requestedBy !== undefined && filter.requestedBy.length > 0) {
+                queryString.set('requested_by', filter.requestedBy);
+            }
+        }
+        return await this.requestCollection(queryString, CommandExecutionEndpoint.parse, null, 'GET');
+    }
+    async getById(id) {
+        const queryString = new QueryString('/system/command-executions/' + id);
+        const result = await this.requestObject(queryString, null, CommandExecutionEndpoint.parse, 'GET');
+        return result.getData();
+    }
+    /** Distinct users that requested commands, resolved to display-safe summaries (for the requester filter). */
+    async getDistinctRequesters() {
+        const queryString = new QueryString('/system/command-executions/users');
+        const result = await this.requestCollection(queryString, CommandExecutionEndpoint.parseSummary, null, 'GET');
+        return result.getData();
+    }
+    static parseSummary(raw) {
+        const summary = new UserSummary();
+        summary.id = raw.id;
+        summary.type = raw.type;
+        summary.state = (raw.state === null || raw.state === undefined) ? null : State.fromString(raw.state);
+        summary.displayName = raw.display_name;
+        return summary;
+    }
+    static parse(raw) {
+        const history = new CommandExecutionHistory();
+        history.id = raw.id;
+        history.commandType = raw.command_type;
+        history.commandTime = Utils.parseRawDate(raw.command_time);
+        history.commandData = DataValueCollection.fromObject(raw.command_data);
+        history.commandVersion = raw.command_version;
+        history.requestedBy = raw.requested_by;
+        history.executionStarted = (raw.execution_started === null || raw.execution_started === undefined) ? null : Utils.parseRawDate(raw.execution_started);
+        history.executionFinished = (raw.execution_finished === null || raw.execution_finished === undefined) ? null : Utils.parseRawDate(raw.execution_finished);
+        history.executionStatus = CommandExecutionStatus.fromString(raw.execution_status);
+        history.executionError = raw.execution_error ?? null;
+        history.executionResult = raw.execution_result ?? null;
+        return history;
+    }
+}

package/dist/Service/ConfigEndpoint.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../Model/Config.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class ConfigEndpoint extends Endpoint {
+    getConfigByFlow(flowId: string, projectEnvironmentId?: string | null): Promise<CollectionResult<Config>>;
+    getByProjectEnvironment(projectEnvironmentId?: string | null): Promise<CollectionResult<Config>>;
+    saveConfigs(projectId: string, configs: Config[]): Promise<CollectionResult<Config>>;
+}

package/dist/Service/ConfigEndpoint.js

@@ -0,0 +1,46 @@
+import { Utils } from '../Utils.js';
+import { Config } from '../Model/Config.js';
+import { Endpoint } from './Endpoint.js';
+export class ConfigEndpoint extends Endpoint {
+    async getConfigByFlow(flowId, projectEnvironmentId = null) {
+        try {
+            let parameters = null;
+            if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
+                parameters = { environment: projectEnvironmentId };
+            }
+            const result = await this.requestCollection('/flows/' + flowId + '/configvalues', Config.parse, parameters);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Unable to load flow configuration', error);
+            }
+            throw error;
+        }
+    }
+    async getByProjectEnvironment(projectEnvironmentId = null) {
+        try {
+            const result = await this.requestCollection('/projectenvironments/' + projectEnvironmentId + '/configvalues', Config.parse);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Unable to load project configuration', error);
+            }
+            throw error;
+        }
+    }
+    async saveConfigs(projectId, configs) {
+        try {
+            const url = '/configvalues';
+            const result = await this.requestCollection(url, Config.parse, configs, 'POST');
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to load config: ', error);
+            }
+            throw error;
+        }
+    }
+}

package/dist/Service/ConfigurationEndpoint.d.ts

@@ -0,0 +1,20 @@
+import { Configuration } from '../Model/Configuration/Configuration.js';
+import { CursorPagination } from '../Model/Pagination/CursorPagination.js';
+import { CollectionResult } from '../Model/Result/CollectionResult.js';
+import { ObjectResult } from '../Model/Result/ObjectResult.js';
+import { Endpoint } from './Endpoint.js';
+export declare class ConfigurationEndpoint extends Endpoint {
+    getByPath(scopeId: string, path: string): Promise<Configuration | null>;
+    getByPathQuery(scopeId: string, pathQuery: string, pagination: CursorPagination): Promise<CollectionResult<Configuration>>;
+    save(scopeId: string, path: string, value: unknown): Promise<CollectionResult<Configuration>>;
+    /**
+     * Remove a configuration row so resolution falls back to the parent scope.
+     * Use this for the "Clear field" / "Inherit from parent" UX action.
+     *
+     * Distinct from `save(scopeId, path, null)` which keeps an explicit "no value"
+     * override at this scope (e.g. for limit fields meaning "no limit").
+     */
+    delete(scopeId: string, path: string): Promise<ObjectResult<{
+        removed: boolean;
+    }>>;
+}

package/dist/Service/ConfigurationEndpoint.js

@@ -0,0 +1,53 @@
+import { QueryString } from '../Http/Data/QueryString.js';
+import { Configuration } from '../Model/Configuration/Configuration.js';
+import { Endpoint } from './Endpoint.js';
+export class ConfigurationEndpoint extends Endpoint {
+    async getByPath(scopeId, path) {
+        try {
+            const qs = new QueryString('/configurations/' + scopeId);
+            qs.set('path', path);
+            const result = await this.requestObject(qs, null, Configuration.parse);
+            return result.getData();
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Unable to load configuration', error);
+            }
+            throw error;
+        }
+    }
+    async getByPathQuery(scopeId, pathQuery, pagination) {
+        try {
+            const qs = new QueryString('/configurations/query/' + scopeId);
+            qs.set('query', pathQuery);
+            qs.addPagination(pagination);
+            const result = await this.requestCollection(qs, Configuration.parse);
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Unable to load configuration', error);
+            }
+            throw error;
+        }
+    }
+    async save(scopeId, path, value) {
+        const qs = new QueryString('/configurations/' + scopeId);
+        qs.set('path', path);
+        const result = await this.requestCollection(qs, Configuration.parse, { value: value }, 'POST');
+        return result;
+    }
+    /**
+     * Remove a configuration row so resolution falls back to the parent scope.
+     * Use this for the "Clear field" / "Inherit from parent" UX action.
+     *
+     * Distinct from `save(scopeId, path, null)` which keeps an explicit "no value"
+     * override at this scope (e.g. for limit fields meaning "no limit").
+     */
+    async delete(scopeId, path) {
+        const qs = new QueryString('/configurations/' + scopeId);
+        qs.set('path', path);
+        const result = await this.requestObject(qs, null, (raw) => raw, 'DELETE');
+        return result;
+    }
+}

package/dist/Service/Endpoint.d.ts

@@ -0,0 +1,16 @@
+import { Parameters } from '../Http/Data/Parameters.js';
+import { QueryString } from '../Http/Data/QueryString.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: 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>>;
+    requestObject<T>(action: string | QueryString, parameters: Parameters | undefined, parser: (input: Record<string, any>) => T, method?: string, signWithOauthToken?: boolean): Promise<ObjectResult<T>>;
+    private toApiError;
+    parseCollection<T>(rawData: object[], parser: (input: any) => T): T[];
+    private parseObject;
+}