attlaz-client 1.9.2 → 1.9.4

package/dist/Model/Log/LogStreamInformation.d.ts

@@ -0,0 +1,7 @@
+import { LogLevel } from './LogLevel';
+import { DataValueValue } from '../DataValue';
+export declare class LogStreamInformation {
+    logLevels: Map<LogLevel, number>;
+    tags: Map<string, (DataValueValue)[]>;
+    static parse(raw: any): LogStreamInformation;
+}

package/dist/Model/Log/LogStreamInformation.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogStreamInformation = void 0;
+const LogLevel_1 = require("./LogLevel");
+class LogStreamInformation {
+    static parse(raw) {
+        const rawData = raw;
+        if (rawData === null || rawData === undefined) {
+            throw new Error('Invalid response');
+        }
+        const logLevels = new Map();
+        Object.keys(rawData.level_count).forEach((logLevelKey, index) => {
+            const logLevel = LogLevel_1.LogLevel.fromString(logLevelKey);
+            const parsedCount = parseInt(rawData.level_count[logLevelKey], undefined);
+            if (parsedCount !== null) {
+                logLevels.set(logLevel, parsedCount);
+            }
+            else {
+                console.error('Unserialize log level count: Unable to parse log level count', rawData.level_count[logLevelKey]);
+            }
+        });
+        const tags = new Map();
+        if (rawData.tags !== null && rawData.tags !== undefined) {
+            Object.keys(rawData.tags).forEach((tagKey, index) => {
+                const values = rawData.tags[tagKey];
+                tags.set(tagKey, values);
+            });
+        }
+        return { logLevels: logLevels, tags };
+    }
+}
+exports.LogStreamInformation = LogStreamInformation;

package/dist/Model/Project/Project.d.ts

@@ -4,8 +4,7 @@ export declare class Project implements StateAware {
     id: string;
     key: string;
     name: string;
-    teamId: string;
-    default: boolean;
+    workspaceId: string;
     defaultEnvironmentId: string;
     state: State;
     constructor(id: string, key: string, name: string);

package/dist/Model/Project/Project.js

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Project = void 0;
 const State_1 = require("../State");
-const Utils_1 = require("../../Utils");
 class Project {
     constructor(id, key, name) {
-        this.default = false;
         this.state = State_1.State.Active;
         this.id = id;
         this.key = key;
@@ -13,16 +11,11 @@ class Project {
     }
     static parse(rawProject) {
         let project = new Project(rawProject.id, rawProject.key, rawProject.name);
-        if (rawProject.team !== undefined) {
-            project.teamId = rawProject.team;
-        }
-        else {
-            project.teamId = rawProject.teamId;
-        }
-        if (rawProject.default !== null && rawProject.default !== undefined) {
-            project.default = Utils_1.Utils.isTrue(rawProject.default);
-        }
-        project.defaultEnvironmentId = rawProject.defaultEnvironmentId;
+        project.workspaceId = rawProject.workspace;
+        // if (rawProject.default !== null && rawProject.default !== undefined) {
+        //     project.default = Utils.isTrue(rawProject.default);
+        // }
+        project.defaultEnvironmentId = rawProject.default_environment;
         project.state = State_1.State.fromString(rawProject.state);
         return project;
     }

package/dist/Model/Result/CollectionResult.d.ts

@@ -1,7 +1,7 @@
 export declare class CollectionResult<T> {
     private data;
     hasMore: boolean;
-    constructor();
+    constructor(data?: T[] | null, hasMore?: boolean);
     setData(data: T[], hasMore: boolean): void;
     getData(): T[];
 }

package/dist/Model/Result/CollectionResult.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionResult = void 0;
 class CollectionResult {
-    constructor() {
+    constructor(data = null, hasMore = false) {
         this.hasMore = false;
-        this.data = [];
+        this.data = data === null ? [] : data;
+        this.hasMore = hasMore;
     }
     // public static parse<T>(raw: any): DataResult<T> {
     //     const result: DataResult<T> = new DataResult<T>();

package/dist/Model/User/UserAction.d.ts

@@ -2,7 +2,7 @@ import { DataValueCollection } from '../DataValueCollection';
 export declare class UserAction {
     id: string;
     userId: string;
-    teamId: string;
+    workspaceId: string;
     action: string;
     resourceId: string;
     resourceType: string;

package/dist/Model/Workspace/Workspace.d.ts

@@ -4,5 +4,5 @@ export declare class Workspace implements StateAware {
     id: string;
     name: string;
     state: State;
-    static parse(rawTeam: any): Workspace;
+    static parse(raw: any): Workspace;
 }

package/dist/Model/Workspace/Workspace.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Workspace = void 0;
 const State_1 = require("../State");
 class Workspace {
-    static parse(rawTeam) {
-        const team = new Workspace();
-        team.id = rawTeam.id;
-        team.name = rawTeam.name;
-        team.state = State_1.State.fromString(rawTeam.state);
-        return team;
+    static parse(raw) {
+        const workspace = new Workspace();
+        workspace.id = raw.id;
+        workspace.name = raw.name;
+        workspace.state = State_1.State.fromString(raw.state);
+        return workspace;
     }
 }
 exports.Workspace = Workspace;

package/dist/Model/Workspace/WorkspaceMemberInvite.d.ts

@@ -3,7 +3,7 @@ import { WorkspaceMemberInviteState } from './WorkspaceMemberInviteState';
 export declare class WorkspaceMemberInvite {
     id: string;
     code: string;
-    teamId: string;
+    workspaceId: string;
     email: string;
     role: WorkspaceMemberRole;
     date: Date;

package/dist/Model/Workspace/WorkspaceMemberInvite2.d.ts

@@ -2,9 +2,9 @@ import { WorkspaceMemberInviteState } from './WorkspaceMemberInviteState';
 export declare class WorkspaceMemberInvite2 {
     code: string;
     email: string | null;
-    inviter_name: string | null;
-    inviter_email: string | null;
-    team_name: string | null;
+    inviterName: string | null;
+    inviterEmail: string | null;
+    workspaceName: string | null;
     state: WorkspaceMemberInviteState;
     static parse(rawInvite: any): WorkspaceMemberInvite2;
 }

package/dist/Model/Workspace/WorkspaceMemberInvite2.js

@@ -7,9 +7,9 @@ class WorkspaceMemberInvite2 {
         return {
             code: rawInvite.code,
             email: rawInvite.email,
-            inviter_name: rawInvite.inviter_name,
-            inviter_email: rawInvite.inviter_email,
-            team_name: rawInvite.team_name,
+            inviterName: rawInvite.inviter_name,
+            inviterEmail: rawInvite.inviter_email,
+            workspaceName: rawInvite.workspace_name,
             state: WorkspaceMemberInviteState_1.WorkspaceMemberInviteState.fromString(rawInvite.state)
         };
     }

package/dist/Model/Workspace/WorkspaceMemberInviteState.js

@@ -15,7 +15,7 @@ var WorkspaceMemberInviteState;
     function fromString(input) {
         const result = Utils_1.Utils.parseEnum(input, WorkspaceMemberInviteState);
         if (result === null) {
-            throw new Error('Unable to parse WorkspaceMemberInviteState from string: Unknown TeamMemberInviteState "' + input + '"');
+            throw new Error('Unable to parse WorkspaceMemberInviteState from string: Unknown WorkspaceMemberInviteState "' + input + '"');
         }
         return result;
     }

package/dist/Service/ChannelEndpoint.js

@@ -29,7 +29,7 @@ class ChannelEndpoint extends Endpoint_1.Endpoint {
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {
-                console.error('Failed to load channels for team "' + workspaceId + '": ', ex);
+                console.error('Failed to load channels for workspace "' + workspaceId + '": ', ex);
             }
             throw ex;
         }
@@ -97,7 +97,15 @@ class ChannelEndpoint extends Endpoint_1.Endpoint {
     async testChannel(subscriberChannel) {
         try {
             let url = '/channels/' + subscriberChannel.id + '/test';
-            const result = await this.httpClient.request(url, {}, 'POST');
+            const parser = (raw) => {
+                return { 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('Something went wrong');
+            }
             return result;
         }
         catch (ex) {

package/dist/Service/FlowRunEndpoint.d.ts

@@ -6,8 +6,8 @@ import { FlowRunHistory } from '../Model/Flow/FlowRunHistory';
 import { CollectionResult } from '../Model/Result/CollectionResult';
 export declare class FlowRunEndpoint extends Endpoint {
     getFlowRuns(flowId: string): Promise<CollectionResult<FlowRun>>;
-    getFlowRunSummaries(flowId: string, from?: Date | null, to?: Date | null, flowRunStatuses?: FlowRunStatus[] | null, projectEnvironmentId?: string | null): Promise<FlowRunSummary[]>;
-    getTaskExecutionSummary(taskExecutionId: string): Promise<FlowRunSummary | null>;
+    getFlowRunSummaries(flowId: string, from?: Date | null, to?: Date | null, flowRunStatuses?: FlowRunStatus[] | null, projectEnvironmentId?: string | null): Promise<CollectionResult<FlowRunSummary>>;
+    getFlowRunSummary(flowRunId: string): Promise<FlowRunSummary | null>;
     getFlowRunHistory(flowRunId: string): Promise<CollectionResult<FlowRunHistory>>;
-    updateTaskExecution(taskExecutionId: string, status: FlowRunStatus, time?: Date | null): Promise<FlowRun>;
+    updateFlowRun(taskExecutionId: string, status: FlowRunStatus, time?: Date | null): Promise<FlowRun>;
 }

package/dist/Service/FlowRunEndpoint.js

@@ -38,12 +38,8 @@ class FlowRunEndpoint extends Endpoint_1.Endpoint {
                 }
                 params.statuses = flowRunStatuses;
             }
-            const rawTaskExecutions = await this.httpClient.request('/flows/' + flowId + '/runsummaries', params);
-            let taskExecutions = [];
-            for (let rawTaskExecution of rawTaskExecutions) {
-                taskExecutions.push(FlowRunSummary_1.FlowRunSummary.parse(rawTaskExecution));
-            }
-            return taskExecutions;
+            const result = await this.requestCollection('/flows/' + flowId + '/runsummaries', params, FlowRunSummary_1.FlowRunSummary.parse);
+            return result;
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -52,13 +48,10 @@ class FlowRunEndpoint extends Endpoint_1.Endpoint {
             throw error;
         }
     }
-    async getTaskExecutionSummary(taskExecutionId) {
+    async getFlowRunSummary(flowRunId) {
         try {
-            const rawTaskExecution = await this.httpClient.request('/taskexecutions/' + taskExecutionId + '/summaries');
-            if (rawTaskExecution === null || rawTaskExecution === undefined) {
-                return null;
-            }
-            return FlowRunSummary_1.FlowRunSummary.parse(rawTaskExecution);
+            const result = await this.requestObject('/taskexecutions/' + flowRunId + '/summaries', null, FlowRunSummary_1.FlowRunSummary.parse);
+            return result;
         }
         catch (error) {
             if (error instanceof ClientError_1.ClientError && error.code === HttpClient_1.HttpClient.HTTP_NOTFOUND) {
@@ -74,7 +67,7 @@ class FlowRunEndpoint extends Endpoint_1.Endpoint {
         const result = await this.requestCollection('/flowruns/' + flowRunId + '/history', null, FlowRunHistory_1.FlowRunHistory.parse);
         return result;
     }
-    async updateTaskExecution(taskExecutionId, status, time = null) {
+    async updateFlowRun(taskExecutionId, status, time = null) {
         if (taskExecutionId.length === 0) {
             throw new Error('Task execution id cannot be empty');
         }
@@ -85,8 +78,12 @@ class FlowRunEndpoint extends Endpoint_1.Endpoint {
         if (!Utils_1.Utils.isNullOrUndefined(time)) {
             params.time = time;
         }
-        const rawTaskExecution = await this.httpClient.request('/taskexecutions/' + taskExecutionId + '', params, 'POST');
-        return FlowRun_1.FlowRun.parse(rawTaskExecution);
+        const result = await this.requestObject('/flowruns/' + taskExecutionId + '', params, FlowRun_1.FlowRun.parse, 'POST');
+        const updatedFlowRun = result.getData();
+        if (updatedFlowRun === null) {
+            throw new Error('FlowRun not updated');
+        }
+        return updatedFlowRun;
     }
 }
 exports.FlowRunEndpoint = FlowRunEndpoint;

package/dist/Service/FlowRunRequestEndpoint.d.ts

@@ -1,5 +1,5 @@
 import { Endpoint } from './Endpoint';
 import { FlowRunResponse } from '../Model/Flow/FlowRunResponse';
 export declare class FlowRunRequestEndpoint extends Endpoint {
-    postTaskExecutionRequest(taskId: string, params: any, wait?: boolean): Promise<FlowRunResponse>;
+    postFlowRunRequest(taskId: string, params: any, wait?: boolean): Promise<FlowRunResponse>;
 }

package/dist/Service/FlowRunRequestEndpoint.js

@@ -3,16 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowRunRequestEndpoint = void 0;
 const Endpoint_1 = require("./Endpoint");
 class FlowRunRequestEndpoint extends Endpoint_1.Endpoint {
-    async postTaskExecutionRequest(taskId, params, wait = false) {
+    async postFlowRunRequest(taskId, params, wait = false) {
         let url = '/flows/' + taskId + '/flowrunrequests';
         if (wait) {
             url = url + "?wait=true";
         }
         try {
-            // TODO: parse
-            const result = await this.httpClient.request(url, params, 'POST');
+            const parser = (raw) => {
+                return raw;
+            };
+            const result = await this.requestObject(url, params, parser, 'POST');
             // console.log('TODO: parse postTaskExecutionRequest result', result);
-            return result;
+            const postedFlowRunResponse = result.getData();
+            if (postedFlowRunResponse === null) {
+                throw new Error('FlowRunResponse not updated');
+            }
+            return postedFlowRunResponse;
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/HealthAlertEndpoint.d.ts

@@ -1,5 +1,6 @@
 import { Endpoint } from './Endpoint';
 import { HealthAlert } from '../Model/HealthAlert/HealthAlert';
+import { CollectionResult } from '../Model/Result/CollectionResult';
 export declare class HealthAlertEndpoint extends Endpoint {
-    getLatestByProjectEnvironment(projectEnvironmentId: string): Promise<HealthAlert[]>;
+    getLatestByProjectEnvironment(projectEnvironmentId: string): Promise<CollectionResult<HealthAlert>>;
 }

package/dist/Service/HealthAlertEndpoint.js

@@ -7,18 +7,8 @@ class HealthAlertEndpoint extends Endpoint_1.Endpoint {
     async getLatestByProjectEnvironment(projectEnvironmentId) {
         try {
             let url = '/projectenvironments/' + projectEnvironmentId + '/health';
-            const result = await this.request(url);
-            // if (Utils.isNullOrUndefined(result)) {
-            //     return null;
-            // }
-            let alerts = [];
-            const resultData = result.getData();
-            if (resultData !== null) {
-                for (let raw of resultData) {
-                    alerts.push(HealthAlert_1.HealthAlert.parse(raw));
-                }
-            }
-            return alerts;
+            const result = await this.requestCollection(url, null, HealthAlert_1.HealthAlert.parse);
+            return result;
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/LogEndpoint.d.ts

@@ -2,16 +2,12 @@ import { Endpoint } from './Endpoint';
 import { LogQuery } from '../Model/Log/LogQuery';
 import { Log } from '../Model/Log/Log';
 import { LogStreamId } from '../Model/Log/LogStreamId';
-import { LogLevel } from '../Model/Log/LogLevel';
-import { DataValueValue } from '../Model/DataValue';
 import { CollectionResult } from '../Model/Result/CollectionResult';
+import { LogStreamInformation } from '../Model/Log/LogStreamInformation';
 export declare class LogEndpoint extends Endpoint {
     getLogs(logQuery: LogQuery): Promise<CollectionResult<Log>>;
     save(log: Log): Promise<Log>;
     delete(logId: string): Promise<boolean>;
     clear(logStreamId: LogStreamId): Promise<boolean>;
-    getInformation(logStreamId: LogStreamId): Promise<{
-        logLevels: Map<LogLevel, number>;
-        tags: Map<string, (DataValueValue)[]>;
-    }>;
+    getInformation(logStreamId: LogStreamId): Promise<LogStreamInformation | null>;
 }

package/dist/Service/LogEndpoint.js

@@ -4,7 +4,7 @@ exports.LogEndpoint = void 0;
 const Endpoint_1 = require("./Endpoint");
 const Log_1 = require("../Model/Log/Log");
 const Utils_1 = require("../Utils");
-const LogLevel_1 = require("../Model/Log/LogLevel");
+const LogStreamInformation_1 = require("../Model/Log/LogStreamInformation");
 class LogEndpoint extends Endpoint_1.Endpoint {
     async getLogs(logQuery) {
         const arrQuery = [];
@@ -40,8 +40,12 @@ class LogEndpoint extends Endpoint_1.Endpoint {
     async save(log) {
         try {
             let cmd = '/logstreams/' + Utils_1.Utils.base64encode(log.logStream.id) + '/logs';
-            const result = await this.request(cmd, log, 'POST');
-            return Log_1.Log.parse(result.getData());
+            const result = await this.requestObject(cmd, log, Log_1.Log.parse, 'POST');
+            const updatedLogEntry = result.getData();
+            if (updatedLogEntry === null) {
+                throw new Error('Log not updated');
+            }
+            return updatedLogEntry;
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -53,8 +57,16 @@ class LogEndpoint extends Endpoint_1.Endpoint {
     async delete(logId) {
         let cmd = '/logstreams/:streamId/logs/' + logId;
         try {
-            const removed = await this.httpClient.request(cmd, null, 'DELETE');
-            return removed;
+            const parser = (raw) => {
+                return { deleted: raw.deleted };
+            };
+            const result = await this.requestObject(cmd, null, parser, 'DELETE');
+            const re = result.getData();
+            if (re === null) {
+                console.log('delete log entry wrong data', { result, parsed: re });
+                throw new Error('Something went wrong');
+            }
+            return re.deleted;
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -66,8 +78,16 @@ class LogEndpoint extends Endpoint_1.Endpoint {
     async clear(logStreamId) {
         let cmd = '/logstreams/' + Utils_1.Utils.base64encode(logStreamId.id) + '/clear';
         try {
-            const removed = await this.httpClient.request(cmd, null, 'POST');
-            return removed;
+            const parser = (raw) => {
+                return { cleared: raw.cleared };
+            };
+            const result = await this.requestObject(cmd, null, parser, 'POST');
+            const re = result.getData();
+            if (re === null) {
+                console.log('Log stream cleared wrong data', { result, parsed: re });
+                throw new Error('Something went wrong');
+            }
+            return re.cleared;
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -79,34 +99,8 @@ class LogEndpoint extends Endpoint_1.Endpoint {
     async getInformation(logStreamId) {
         try {
             let url = '/logstreams/' + Utils_1.Utils.base64encode(logStreamId.id) + '/info';
-            const dataResult = await this.request(url);
-            if (Utils_1.Utils.isNullOrUndefined(dataResult)) {
-                throw new Error('Invalid response');
-            }
-            const data = dataResult.getData();
-            if (data === null) {
-                throw new Error('Invalid response');
-            }
-            const rawData = data;
-            const logLevels = new Map();
-            Object.keys(rawData.level_count).forEach((logLevelKey, index) => {
-                const logLevel = LogLevel_1.LogLevel.fromString(logLevelKey);
-                const parsedCount = parseInt(rawData.level_count[logLevelKey], undefined);
-                if (parsedCount !== null) {
-                    logLevels.set(logLevel, parsedCount);
-                }
-                else {
-                    console.error('Unserialize log level count: Unable to parse log level count', rawData.level_count[logLevelKey]);
-                }
-            });
-            const tags = new Map();
-            if (rawData.tags !== null && rawData.tags !== undefined) {
-                Object.keys(rawData.tags).forEach((tagKey, index) => {
-                    const values = rawData.tags[tagKey];
-                    tags.set(tagKey, values);
-                });
-            }
-            return { logLevels: logLevels, tags };
+            const result = await this.requestObject(url, null, LogStreamInformation_1.LogStreamInformation.parse);
+            return result.getData();
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/ProjectDeployEndpoint.d.ts

@@ -5,5 +5,5 @@ export declare class ProjectDeployEndpoint extends Endpoint {
     getById(deployId: string): Promise<ProjectDeploy | null>;
     getLatestDeploy(codeSourceId: string): Promise<ProjectDeploy | null>;
     getByCodeSource(codeSourceId: string): Promise<CollectionResult<ProjectDeploy>>;
-    requestDeploy(codeSourceId: string): Promise<any>;
+    requestDeploy(codeSourceId: string): Promise<ProjectDeploy>;
 }

package/dist/Service/ProjectDeployEndpoint.js

@@ -42,9 +42,12 @@ class ProjectDeployEndpoint extends Endpoint_1.Endpoint {
     }
     async requestDeploy(codeSourceId) {
         try {
-            const projectDeploy = await this.request('/codesources/' + codeSourceId + '/deploys', {}, 'POST');
-            // TODO: parse deploy
-            return projectDeploy;
+            const result = await this.requestObject('/codesources/' + codeSourceId + '/deploys', null, ProjectDeploy_1.ProjectDeploy.parse, 'POST');
+            const requestedDeploy = result.getData();
+            if (requestedDeploy === null) {
+                throw new Error('ProjectDeploy not requested');
+            }
+            return requestedDeploy;
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/ProjectEndpoint.d.ts

@@ -3,7 +3,7 @@ import { Project } from '../Model/Project/Project';
 import { CollectionResult } from '../Model/Result/CollectionResult';
 export declare class ProjectEndpoint extends Endpoint {
     getAll(): Promise<CollectionResult<Project>>;
-    getByTeam(teamId: string): Promise<CollectionResult<Project>>;
+    getByWorkspace(workspaceId: string): Promise<CollectionResult<Project>>;
     getById(projectId: string): Promise<Project | null>;
     save(project: Project): Promise<Project>;
 }

package/dist/Service/ProjectEndpoint.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectEndpoint = void 0;
 const Endpoint_1 = require("./Endpoint");
 const Project_1 = require("../Model/Project/Project");
-const Utils_1 = require("../Utils");
-const HttpClient_1 = require("../Http/HttpClient");
 class ProjectEndpoint extends Endpoint_1.Endpoint {
     async getAll() {
         try {
@@ -18,9 +16,9 @@ class ProjectEndpoint extends Endpoint_1.Endpoint {
             throw e;
         }
     }
-    async getByTeam(teamId) {
+    async getByWorkspace(workspaceId) {
         try {
-            const result = await this.requestCollection('teams/' + teamId + '/projects', null, Project_1.Project.parse);
+            const result = await this.requestCollection('workspaces/' + workspaceId + '/projects', null, Project_1.Project.parse);
             return result;
         }
         catch (e) {
@@ -32,16 +30,10 @@ class ProjectEndpoint extends Endpoint_1.Endpoint {
     }
     async getById(projectId) {
         try {
-            const rawProject = await this.httpClient.request('projects/' + projectId + '');
-            if (Utils_1.Utils.isNullOrUndefined(rawProject)) {
-                return null;
-            }
-            return Project_1.Project.parse(rawProject);
+            const result = await this.requestObject('projects/' + projectId + '', null, Project_1.Project.parse);
+            return result;
         }
         catch (error) {
-            if (error.code === HttpClient_1.HttpClient.HTTP_NOTFOUND) {
-                return null;
-            }
             if (this.httpClient.isDebugEnabled()) {
                 console.error('Failed to load project by id: ' + error);
             }

package/dist/Service/StorageEndpoint.d.ts

@@ -1,14 +1,14 @@
 import { Endpoint } from './Endpoint';
-import { DataResult } from '../Model/Result/DataResult';
 import { StorageType } from '../Model/Storage/StorageType';
 import { StorageInformation } from '../Model/Storage/StorageInformation';
 import { StorageItem } from '../Model/Storage/StorageItem';
 import { StorageItemInformation } from '../Model/Storage/StorageItemInformation';
+import { CollectionResult } from '../Model/Result/CollectionResult';
 export declare class StorageEndpoint extends Endpoint {
-    getInformation(projectEnvironmentId: string, storageType: StorageType): Promise<DataResult<StorageInformation>>;
-    clearPool(projectEnvironmentId: string, storageType: StorageType, poolKey: string): Promise<DataResult<any>>;
-    getPoolItemsInformation(projectEnvironmentId: string, storageType: StorageType, poolKey: string): Promise<DataResult<StorageItemInformation[]>>;
+    getInformation(projectEnvironmentId: string, storageType: StorageType): Promise<StorageInformation | null>;
+    clearPool(projectEnvironmentId: string, storageType: StorageType, poolKey: string): Promise<boolean>;
+    getPoolItemsInformation(projectEnvironmentId: string, storageType: StorageType, poolKey: string): Promise<CollectionResult<StorageItemInformation>>;
     getItem(projectEnvironmentId: string, storageType: StorageType, poolKey: string, storageItemKey: string): Promise<StorageItem | null>;
-    setItem(projectEnvironmentId: string, storageType: StorageType, poolKey: string, storageItem: StorageItem): Promise<void>;
-    deleteItem(projectEnvironmentId: string, storageType: StorageType, poolKey: string, storageItemKey: string): Promise<DataResult<StorageItem>>;
+    setItem(projectEnvironmentId: string, storageType: StorageType, poolKey: string, storageItem: StorageItem): Promise<StorageItem>;
+    deleteItem(projectEnvironmentId: string, storageType: StorageType, poolKey: string, storageItemKey: string): Promise<boolean>;
 }

package/dist/Service/StorageEndpoint.js

@@ -8,8 +8,11 @@ class StorageEndpoint extends Endpoint_1.Endpoint {
     async getInformation(projectEnvironmentId, storageType) {
         let cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType;
         try {
-            const result = await this.request(cmd, null, 'GET');
-            return result;
+            const parser = (raw) => {
+                return raw;
+            };
+            const result = await this.requestObject(cmd, null, parser, 'GET');
+            return result.getData();
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {
@@ -21,8 +24,16 @@ class StorageEndpoint extends Endpoint_1.Endpoint {
     async clearPool(projectEnvironmentId, storageType, poolKey) {
         let cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + poolKey;
         try {
-            const result = await this.request(cmd, null, 'DELETE');
-            return result;
+            const parser = (raw) => {
+                return raw.cleared;
+            };
+            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('Something went wrong');
+            }
+            return re.cleared;
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {
@@ -34,8 +45,7 @@ class StorageEndpoint extends Endpoint_1.Endpoint {
     async getPoolItemsInformation(projectEnvironmentId, storageType, poolKey) {
         let cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + poolKey + '/items';
         try {
-            const result = await this.request(cmd, null, 'GET');
-            result.setData(this.parseCollection(result, StorageItemInformation_1.StorageItemInformation.parse));
+            const result = await this.requestCollection(cmd, null, StorageItemInformation_1.StorageItemInformation.parse, 'GET');
             return result;
         }
         catch (ex) {
@@ -48,11 +58,8 @@ class StorageEndpoint extends Endpoint_1.Endpoint {
     async getItem(projectEnvironmentId, storageType, poolKey, storageItemKey) {
         let cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + poolKey + '/items/' + storageItemKey;
         try {
-            const result = await this.request(cmd, null, 'GET');
-            if (!result.hasData()) {
-                return null;
-            }
-            return StorageItem_1.StorageItem.parse(result.getData());
+            const result = await this.requestObject(cmd, null, StorageItem_1.StorageItem.parse, 'GET');
+            return result.getData();
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {
@@ -64,8 +71,13 @@ class StorageEndpoint extends Endpoint_1.Endpoint {
     async setItem(projectEnvironmentId, storageType, poolKey, storageItem) {
         let cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + poolKey + '/items/' + storageItem.key;
         try {
-            const result = await this.request(cmd, { 'storage_item': storageItem }, 'POST');
-            return;
+            const result = await this.requestObject(cmd, { 'storage_item': storageItem }, StorageItem_1.StorageItem.parse, 'POST');
+            const savedItem = result.getData();
+            if (savedItem === null) {
+                console.log('Storage set item wrong data', { result, parsed: savedItem });
+                throw new Error('Something went wrong');
+            }
+            return savedItem;
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {
@@ -77,8 +89,16 @@ class StorageEndpoint extends Endpoint_1.Endpoint {
     async deleteItem(projectEnvironmentId, storageType, poolKey, storageItemKey) {
         let cmd = '/projectenvironments/' + projectEnvironmentId + '/storage/' + storageType + '/' + poolKey + '/items/' + storageItemKey;
         try {
-            const result = await this.request(cmd, null, 'DELETE');
-            return result;
+            const parser = (raw) => {
+                return { deleted: raw.deleted };
+            };
+            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('Something went wrong');
+            }
+            return x.deleted;
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/UserEndpoint.js

@@ -12,10 +12,18 @@ class UserEndpoint extends Endpoint_1.Endpoint {
     }
     async authenticateByAuthProvider(providerType, data) {
         try {
-            const result = await this.request('/auth/providers/' + providerType, data, 'POST', false);
-            // TODO: should we validate this more?
-            const token = result;
-            token.expires = new Date(result.expires);
+            const parser = (raw) => {
+                // TODO: should we validate this more?
+                const token = raw;
+                token.expires = new Date(raw.expires);
+                return token;
+            };
+            const result = await this.requestObject('/auth/providers/' + providerType, data, parser, 'POST', false);
+            const token = result.getData();
+            if (token === null) {
+                console.log('auth by auth provider wrong data', { result, parsed: token });
+                throw new Error('Something went wrong');
+            }
             return token;
         }
         catch (e) {
@@ -27,7 +35,11 @@ class UserEndpoint extends Endpoint_1.Endpoint {
     }
     async createAuthProvider(providerType, data) {
         try {
-            const result = await this.request('/user/auth/providers', { provider_type: providerType, code: data.code, state: data.state }, 'POST');
+            const parser = (raw) => {
+                return raw;
+            };
+            const result = await this.requestObject('/user/auth/providers', { provider_type: providerType, code: data.code, state: data.state }, parser, 'POST');
+            // TODO validation
             return true;
         }
         catch (e) {
@@ -39,8 +51,16 @@ class UserEndpoint extends Endpoint_1.Endpoint {
     }
     async removeAuthProvider(providerId) {
         try {
-            const result = await this.request('/user/auth/providers', { provider: providerId }, 'DELETE');
-            return true;
+            const parser = (raw) => {
+                return { deleted: raw.deleted };
+            };
+            const result = await this.requestObject('/user/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('Something went wrong');
+            }
+            return re.deleted;
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -95,8 +115,16 @@ class UserEndpoint extends Endpoint_1.Endpoint {
     async requestResetPassword(email) {
         try {
             let url = '/users/resetpassword';
-            const result = await this.request(url, { email }, 'POST', false);
-            return true;
+            const parser = (raw) => {
+                return { requested: raw.requested };
+            };
+            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('Something went wrong');
+            }
+            return re.requested;
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -108,8 +136,16 @@ class UserEndpoint extends Endpoint_1.Endpoint {
     async resetPassword(code, password) {
         try {
             let url = '/users/resetpassword/' + code;
-            const result = await this.request(url, { password }, 'POST', false);
-            return true;
+            const parser = (raw) => {
+                return { updated: raw.updated };
+            };
+            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('Something went wrong');
+            }
+            return re.updated;
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {

package/dist/Service/WorkspaceMemberEndpoint.d.ts

@@ -1,5 +1,4 @@
 import { Endpoint } from './Endpoint';
-import { DataResult } from '../Model/Result/DataResult';
 import { UserAction } from '../Model/User/UserAction';
 import { WorkspaceMember } from '../Model/Workspace/WorkspaceMember';
 import { WorkspaceMemberInvite } from '../Model/Workspace/WorkspaceMemberInvite';
@@ -7,8 +6,8 @@ import { WorkspaceMemberInvite2 } from '../Model/Workspace/WorkspaceMemberInvite
 import { CollectionResult } from '../Model/Result/CollectionResult';
 export declare class WorkspaceMemberEndpoint extends Endpoint {
     getByWorkspace(workspaceId: string): Promise<CollectionResult<WorkspaceMember>>;
-    invite(teamId: string, invites: WorkspaceMemberInvite[]): Promise<DataResult<void>>;
+    invite(workspaceId: string, invites: WorkspaceMemberInvite[]): Promise<boolean>;
     getWorkspaceInviteByCode(inviteCode: string): Promise<WorkspaceMemberInvite2 | null>;
-    getTeamMemberEvents(teamId: string, memberId: string): Promise<CollectionResult<UserAction>>;
+    getWorkspaceMemberEvents(workspaceId: string, memberId: string): Promise<CollectionResult<UserAction>>;
     private static parse;
 }

package/dist/Service/WorkspaceMemberEndpoint.js

@@ -34,22 +34,31 @@ class WorkspaceMemberEndpoint extends Endpoint_1.Endpoint {
         const result = await this.requestCollection(cmd, null, parser);
         return result;
     }
-    async invite(teamId, invites) {
-        let cmd = '/workspaces/' + teamId + '/invites';
+    async invite(workspaceId, invites) {
+        let cmd = '/workspaces/' + workspaceId + '/invites';
         const rawInvites = [];
         for (let invite of invites) {
             rawInvites.push({ email: invite.email, role: invite.role.toString() });
         }
         try {
-            const result = await this.request(cmd, { invites: rawInvites }, 'POST');
+            const parser = (raw) => {
+                return raw;
+            };
+            const result = await this.requestObject(cmd, { invites: rawInvites }, parser, 'POST');
+            const re = result.getData();
+            if (re === null) {
+                console.log('invite member wrong data', { result, parsed: re });
+                throw new Error('Something went wrong');
+            }
             // if (Utils.isNullOrUndefined(result)) {
             //     return null;
             // }
-            return result;
+            console.log('Invite', re);
+            return true;
         }
         catch (ex) {
             if (this.httpClient.isDebugEnabled()) {
-                console.error('Failed to invite members to team "' + teamId + '": ', ex);
+                console.error('Failed to invite members to workspace "' + workspaceId + '": ', ex);
             }
             throw ex;
         }
@@ -62,9 +71,9 @@ class WorkspaceMemberEndpoint extends Endpoint_1.Endpoint {
         }
         return null;
     }
-    async getTeamMemberEvents(teamId, memberId) {
+    async getWorkspaceMemberEvents(workspaceId, memberId) {
         try {
-            const url = '/teams/' + teamId + '/members/' + memberId + '/events';
+            const url = '/workspaces/' + workspaceId + '/members/' + memberId + '/events';
             const result = await this.requestCollection(url, null, WorkspaceMemberEndpoint.parse, 'GET');
             return result;
         }
@@ -79,7 +88,7 @@ class WorkspaceMemberEndpoint extends Endpoint_1.Endpoint {
         const userAction = new UserAction_1.UserAction();
         userAction.id = rawUserEvent.id;
         userAction.userId = rawUserEvent.user;
-        userAction.teamId = rawUserEvent.team;
+        userAction.workspaceId = rawUserEvent.workspace;
         userAction.action = rawUserEvent.action;
         userAction.resourceId = rawUserEvent.resource_id;
         userAction.resourceType = rawUserEvent.resource_type;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.9.2";
+export declare const VERSION = "1.9.4";

package/dist/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
-exports.VERSION = "1.9.2";
+exports.VERSION = "1.9.4";

package/package.json

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