attlaz-client 1.7.1 → 1.7.2

package/dist/Service/TriggerEndpoint.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TriggerEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Trigger_1 = require("../Model/Trigger/Trigger");
-const Utils_1 = require("../Utils");
-class TriggerEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Trigger } from '../Model/Trigger/Trigger';
+import { Utils } from '../Utils';
+export class TriggerEndpoint extends Endpoint {
     async getByTask(taskId, projectEnvironmentId = null) {
         try {
             let parameters = null;
-            if (!Utils_1.Utils.isNullOrUndefined(projectEnvironmentId)) {
+            if (!Utils.isNullOrUndefined(projectEnvironmentId)) {
                 parameters = { environment: projectEnvironmentId };
             }
             const rawTriggers = await this.httpClient.request('/tasks/' + taskId + '/triggers', parameters);
             let triggers = [];
             for (let rawTrigger of rawTriggers) {
-                triggers.push(Trigger_1.Trigger.parse(rawTrigger));
+                triggers.push(Trigger.parse(rawTrigger));
             }
             return triggers;
         }
@@ -28,10 +25,10 @@ class TriggerEndpoint extends Endpoint_1.Endpoint {
     async getById(id) {
         try {
             const result = await this.httpClient.request('/triggers/' + id);
-            if (Utils_1.Utils.isNullOrUndefined(result)) {
+            if (Utils.isNullOrUndefined(result)) {
                 throw new Error('Unable to get trigger');
             }
-            return Trigger_1.Trigger.parse(result);
+            return Trigger.parse(result);
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -44,7 +41,7 @@ class TriggerEndpoint extends Endpoint_1.Endpoint {
         try {
             let url = '/tasks/' + trigger.task + '/triggers';
             const result = await this.httpClient.request(url, trigger, 'POST');
-            return Trigger_1.Trigger.parse(result);
+            return Trigger.parse(result);
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -54,4 +51,3 @@ class TriggerEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.TriggerEndpoint = TriggerEndpoint;

package/dist/Service/UserEndpoint.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UserEndpoint = void 0;
-const UserAuthProvider_1 = require("../Model/User/UserAuthProvider");
-const Endpoint_1 = require("./Endpoint");
-const User_1 = require("../Model/User");
-const Utils_1 = require("../Utils");
-class UserEndpoint extends Endpoint_1.Endpoint {
+import { UserAuthProvider } from '../Model/User/UserAuthProvider';
+import { Endpoint } from './Endpoint';
+import { User } from '../Model/User';
+import { Utils } from '../Utils';
+export class UserEndpoint extends Endpoint {
     async getUser() {
         let cmd = '/user';
         const rawUser = await this.httpClient.request(cmd);
-        if (Utils_1.Utils.isNullOrUndefined(rawUser)) {
+        if (Utils.isNullOrUndefined(rawUser)) {
             throw new Error('User not found');
         }
-        return User_1.User.parse(rawUser);
+        return User.parse(rawUser);
     }
     async authenticateByAuthProvider(providerType, data) {
         try {
@@ -56,14 +53,14 @@ class UserEndpoint extends Endpoint_1.Endpoint {
     async getAuthProviders() {
         let cmd = '/user/auth/providers';
         const rawAuthProviders = await this.request(cmd);
-        rawAuthProviders.setData(this.parseCollection(rawAuthProviders, UserAuthProvider_1.UserAuthProvider.parse));
+        rawAuthProviders.setData(this.parseCollection(rawAuthProviders, UserAuthProvider.parse));
         return rawAuthProviders;
     }
     async update(user) {
         try {
             let url = '/user/' + user.id;
             const result = await this.httpClient.request(url, { user }, 'POST');
-            return User_1.User.parse(result);
+            return User.parse(result);
         }
         catch (e) {
             if (this.httpClient.isDebugEnabled()) {
@@ -79,7 +76,7 @@ class UserEndpoint extends Endpoint_1.Endpoint {
             const result = await this.request(url, data, 'PUT', false);
             const resultData = result.getData();
             if (resultData !== null && resultData.createdUser !== null) {
-                result.setData({ createdUser: User_1.User.parse(resultData.createdUser) });
+                result.setData({ createdUser: User.parse(resultData.createdUser) });
             }
             return result;
         }
@@ -117,4 +114,3 @@ class UserEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.UserEndpoint = UserEndpoint;

package/dist/Service/WorkerConfigEndpoint.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerConfigEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Utils_1 = require("../Utils");
-const WorkerConfig_1 = require("../Model/Worker/WorkerConfig");
-class WorkerConfigEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Utils } from '../Utils';
+import { WorkerConfig } from '../Model/Worker/WorkerConfig';
+export class WorkerConfigEndpoint extends Endpoint {
     async getByProjectEnvironment(projectEnvironmentId) {
         try {
             let url = '/projectenvironments/' + projectEnvironmentId + '/workerconfiguration';
             const result = await this.request(url);
-            if (Utils_1.Utils.isNullOrUndefined(result)) {
+            if (Utils.isNullOrUndefined(result)) {
                 throw new Error('Unable to get project environment');
             }
             const resultData = result.getData();
@@ -18,7 +15,7 @@ class WorkerConfigEndpoint extends Endpoint_1.Endpoint {
             }
             let workerConfigValues = [];
             for (let rawConfig of resultData) {
-                workerConfigValues.push(WorkerConfig_1.WorkerConfig.parse(rawConfig));
+                workerConfigValues.push(WorkerConfig.parse(rawConfig));
             }
             return workerConfigValues;
         }
@@ -34,7 +31,7 @@ class WorkerConfigEndpoint extends Endpoint_1.Endpoint {
             let url = '/projectenvironments/' + workerConfig.projectEnvironment + '/workerconfiguration';
             const result = await this.request(url, workerConfig, 'POST');
             console.log(result);
-            return WorkerConfig_1.WorkerConfig.parse(result);
+            return WorkerConfig.parse(result);
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -44,4 +41,3 @@ class WorkerConfigEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.WorkerConfigEndpoint = WorkerConfigEndpoint;

package/dist/Service/WorkerEndpoint.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WorkerEndpoint = void 0;
-const Endpoint_1 = require("./Endpoint");
-const Utils_1 = require("../Utils");
-const Worker_1 = require("../Model/Worker/Worker");
-const DataResult_1 = require("../Model/Result/DataResult");
-class WorkerEndpoint extends Endpoint_1.Endpoint {
+import { Endpoint } from './Endpoint';
+import { Utils } from '../Utils';
+import { Worker } from '../Model/Worker/Worker';
+import { DataResult } from '../Model/Result/DataResult';
+export class WorkerEndpoint extends Endpoint {
     async getByProjectEnvironment(projectEnvironmentId) {
         try {
             let url = '/projectenvironments/' + projectEnvironmentId + '/workers';
             const result = await this.httpClient.request(url);
-            if (Utils_1.Utils.isNullOrUndefined(result)) {
+            if (Utils.isNullOrUndefined(result)) {
                 throw new Error('Unable to find worker');
             }
-            return new DataResult_1.DataResult(Worker_1.Worker.parse(result));
+            return new DataResult(Worker.parse(result));
         }
         catch (error) {
             if (this.httpClient.isDebugEnabled()) {
@@ -36,4 +33,3 @@ class WorkerEndpoint extends Endpoint_1.Endpoint {
         }
     }
 }
-exports.WorkerEndpoint = WorkerEndpoint;

package/dist/Utils.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Utils = void 0;
-class Utils {
+export class Utils {
     static isNullOrUndefined(variable) {
         return variable === null || variable === undefined;
     }
@@ -58,4 +55,3 @@ class Utils {
         // return typeof obj[Symbol.iterator] === 'function';
     }
 }
-exports.Utils = Utils;

package/dist/Utils.spec.js

@@ -1,40 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const TriggerType_1 = require("./Model/Trigger/TriggerType");
-const TaskExecutionStatus_1 = require("./Model/TaskExecutionStatus");
-const ChannelType_1 = require("./Model/Messaging/Channel/ChannelType");
-const ProjectDeployStatus_1 = require("./Model/Project/ProjectDeployStatus");
-const State_1 = require("./Model/State");
-const LogLevel_1 = require("./Model/Log/LogLevel");
-const StorageType_1 = require("./Model/Storage/StorageType");
-const WorkerInstanceState_1 = require("./Model/Worker/WorkerInstanceState");
-const WorkerState_1 = require("./Model/Worker/WorkerState");
-const Utils_1 = require("./Utils");
+import { TriggerType } from './Model/Trigger/TriggerType';
+import { TaskExecutionStatus } from './Model/TaskExecutionStatus';
+import { ChannelType } from './Model/Messaging/Channel/ChannelType';
+import { ProjectDeployStatus } from './Model/Project/ProjectDeployStatus';
+import { State } from './Model/State';
+import { LogLevel } from './Model/Log/LogLevel';
+import { StorageType } from './Model/Storage/StorageType';
+import { WorkerInstanceState } from './Model/Worker/WorkerInstanceState';
+import { WorkerState } from './Model/Worker/WorkerState';
+import { Utils } from './Utils';
 test('Test enum parsing', () => {
-    expect(TriggerType_1.TriggerType.fromString('webhook')).toBe(TriggerType_1.TriggerType.Webhook);
-    expect(TaskExecutionStatus_1.TaskExecutionStatus.fromString('complete')).toBe(TaskExecutionStatus_1.TaskExecutionStatus.Complete);
-    expect(ChannelType_1.ChannelType.fromString('slack')).toBe(ChannelType_1.ChannelType.Slack);
-    expect(LogLevel_1.LogLevel.fromString('debug')).toBe(LogLevel_1.LogLevel.Debug);
-    expect(ProjectDeployStatus_1.ProjectDeployStatus.fromString('complete')).toBe(ProjectDeployStatus_1.ProjectDeployStatus.Complete);
-    expect(StorageType_1.StorageType.fromString('cache')).toBe(StorageType_1.StorageType.Cache);
-    expect(State_1.State.fromString('active')).toBe(State_1.State.Active);
-    expect(WorkerInstanceState_1.WorkerInstanceState.fromString('started')).toBe(WorkerInstanceState_1.WorkerInstanceState.Started);
-    expect(WorkerState_1.WorkerState.fromString('active')).toBe(WorkerState_1.WorkerState.Active);
+    expect(TriggerType.fromString('webhook')).toBe(TriggerType.Webhook);
+    expect(TaskExecutionStatus.fromString('complete')).toBe(TaskExecutionStatus.Complete);
+    expect(ChannelType.fromString('slack')).toBe(ChannelType.Slack);
+    expect(LogLevel.fromString('debug')).toBe(LogLevel.Debug);
+    expect(ProjectDeployStatus.fromString('complete')).toBe(ProjectDeployStatus.Complete);
+    expect(StorageType.fromString('cache')).toBe(StorageType.Cache);
+    expect(State.fromString('active')).toBe(State.Active);
+    expect(WorkerInstanceState.fromString('started')).toBe(WorkerInstanceState.Started);
+    expect(WorkerState.fromString('active')).toBe(WorkerState.Active);
 });
 test('Test base64 encode/decode', () => {
-    expect(Utils_1.Utils.base64encode('Lorem ipsum')).toBe('TG9yZW0gaXBzdW0=');
-    expect(Utils_1.Utils.base64decode('TG9yZW0gaXBzdW0=')).toBe('Lorem ipsum');
+    expect(Utils.base64encode('Lorem ipsum')).toBe('TG9yZW0gaXBzdW0=');
+    expect(Utils.base64decode('TG9yZW0gaXBzdW0=')).toBe('Lorem ipsum');
 });
 test('Test if iterable', async () => {
-    expect(Utils_1.Utils.isIterable(null)).toBe(false);
-    expect(Utils_1.Utils.isIterable('')).toBe(false);
-    expect(Utils_1.Utils.isIterable('Lorem')).toBe(false);
-    expect(Utils_1.Utils.isIterable(false)).toBe(false);
-    expect(Utils_1.Utils.isIterable(true)).toBe(false);
-    expect(Utils_1.Utils.isIterable(undefined)).toBe(false);
-    expect(Utils_1.Utils.isIterable(12)).toBe(false);
-    expect(Utils_1.Utils.isIterable([])).toBe(true);
-    expect(Utils_1.Utils.isIterable(['L', 'O', 'R', 'E', 'M'])).toBe(true);
-    expect(Utils_1.Utils.isIterable({})).toBe(false);
-    expect(Utils_1.Utils.isIterable({ a: 'a', b: 'b' })).toBe(false);
+    expect(Utils.isIterable(null)).toBe(false);
+    expect(Utils.isIterable('')).toBe(false);
+    expect(Utils.isIterable('Lorem')).toBe(false);
+    expect(Utils.isIterable(false)).toBe(false);
+    expect(Utils.isIterable(true)).toBe(false);
+    expect(Utils.isIterable(undefined)).toBe(false);
+    expect(Utils.isIterable(12)).toBe(false);
+    expect(Utils.isIterable([])).toBe(true);
+    expect(Utils.isIterable(['L', 'O', 'R', 'E', 'M'])).toBe(true);
+    expect(Utils.isIterable({})).toBe(false);
+    expect(Utils.isIterable({ a: 'a', b: 'b' })).toBe(false);
 });

package/dist/auth.spec.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Client_1 = require("./Client");
-const OAuthClientToken_1 = require("./Http/OAuthClientToken");
-const Utils_1 = require("./Utils");
-const HttpClient_1 = require("./Http/HttpClient");
+import { Client } from './Client';
+import { OAuthClientToken } from './Http/OAuthClientToken';
+import { Utils } from './Utils';
+import { HttpClient } from './Http/HttpClient';
 jest.setTimeout((60) * 1000);
 // const apiEndpoint: string = 'http://localhost:5728/';
 const apiEndpoint = 'https://api2.attlaz.com';
@@ -16,7 +14,7 @@ const passwordFlowPassword = 'koetjeboe';
 const tokenExpirationInSeconds = 5;
 test('Test client credentials flow', async () => {
     expect.assertions(2);
-    let client = new Client_1.Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
+    let client = new Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate();
     const user = await client.getUserEndpoint().getUser();
@@ -43,14 +41,14 @@ test('Test client credentials flow', async () => {
         if (token === null) {
             throw new Error('Token is null');
         }
-        expect(OAuthClientToken_1.OAuthClientToken.isExpired(token)).toBeTruthy();
+        expect(OAuthClientToken.isExpired(token)).toBeTruthy();
     }
     // const user2: User = await client.getUserEndpoint().getUser()
     // expect(user.email).toBe('demo@attlaz.com');
 });
 test('Test password authentication - valid', async () => {
     expect.assertions(3);
-    let client = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate(passwordFlowUsername, passwordFlowPassword);
     const user = await client.getUserEndpoint().getUser();
@@ -64,41 +62,41 @@ test('Test password authentication - valid', async () => {
     if (token === null) {
         throw new Error('Token is null');
     }
-    expect(OAuthClientToken_1.OAuthClientToken.isExpired(token)).toBeTruthy();
+    expect(OAuthClientToken.isExpired(token)).toBeTruthy();
     const user2 = await client.getUserEndpoint().getUser();
     expect(user2.email).toBe(passwordFlowUsername);
 });
 test('Test password authentication - invalid', async () => {
     expect.assertions(3);
-    let client = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client.getHttpClient().enableDebug();
     await expect(client.authenticate(passwordFlowUsername, 'wrongpassword'))
         .rejects
-        .toHaveProperty('code', HttpClient_1.HttpClient.HTTP_UNAUTHORIZED);
+        .toHaveProperty('code', HttpClient.HTTP_UNAUTHORIZED);
     await expect(client.getUserEndpoint().getUser())
         .rejects
         .toHaveProperty('message', 'Unable to perform request, access token not provided');
     await expect(client.authenticate('wrongusername', 'wrongpassword'))
         .rejects
-        .toHaveProperty('code', HttpClient_1.HttpClient.HTTP_UNAUTHORIZED);
+        .toHaveProperty('code', HttpClient.HTTP_UNAUTHORIZED);
 });
 test('Test set access token + JSON encode', async () => {
     expect.assertions(4);
-    let client = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate(passwordFlowUsername, passwordFlowPassword);
     const token = client.getToken();
     if (token === null) {
         throw new Error('Token is null');
     }
-    expect(OAuthClientToken_1.OAuthClientToken.isExpired(token)).toBeFalsy();
-    const encoded = OAuthClientToken_1.OAuthClientToken.serialize(token);
+    expect(OAuthClientToken.isExpired(token)).toBeFalsy();
+    const encoded = OAuthClientToken.serialize(token);
     console.log(encoded);
-    const decodedToken = OAuthClientToken_1.OAuthClientToken.deserialize(encoded);
+    const decodedToken = OAuthClientToken.deserialize(encoded);
     client.setToken(decodedToken);
     const user = await client.getUserEndpoint().getUser();
     expect(user.email).toBe(passwordFlowUsername);
-    let client2 = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client2 = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client2.getHttpClient().enableDebug();
     console.log(decodedToken);
     client2.setToken(decodedToken);
@@ -122,19 +120,19 @@ test('Test set access token + JSON encode', async () => {
 });
 test('Test set expired tokens', async () => {
     expect.assertions(4);
-    let client = new Client_1.Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
+    let client = new Client(apiEndpoint, passwordFlowClientId, passwordFlowClientSecret);
     client.getHttpClient().enableDebug();
-    const encodedToken = Utils_1.Utils.base64decode('eyJhY2Nlc3NfdG9rZW4iOiJvZVZpYXVhdk9wTkNpekNLRmxXUGpuaEI5aHNSdFViMFFTTVJlQWFuIiwidG9rZW5fdHlwZSI6ImJlYXJlciIsInJlZnJlc2hfdG9rZW4iOiJ4N0pINTVaR3U5OGFPN3VQaGlmS2RZME8yc3BYS0IzN296bElDUGtJIiwiZXhwaXJlcyI6IjIwMjEtMDMtMTlUMjE6MTQ6MTkuNzkyWiIsInNjb3BlIjoiYWxsIn0=');
-    const token = OAuthClientToken_1.OAuthClientToken.deserialize(encodedToken);
+    const encodedToken = Utils.base64decode('eyJhY2Nlc3NfdG9rZW4iOiJvZVZpYXVhdk9wTkNpekNLRmxXUGpuaEI5aHNSdFViMFFTTVJlQWFuIiwidG9rZW5fdHlwZSI6ImJlYXJlciIsInJlZnJlc2hfdG9rZW4iOiJ4N0pINTVaR3U5OGFPN3VQaGlmS2RZME8yc3BYS0IzN296bElDUGtJIiwiZXhwaXJlcyI6IjIwMjEtMDMtMTlUMjE6MTQ6MTkuNzkyWiIsInNjb3BlIjoiYWxsIn0=');
+    const token = OAuthClientToken.deserialize(encodedToken);
     client.setToken(token);
-    expect(OAuthClientToken_1.OAuthClientToken.isExpired(token)).toBeTruthy();
+    expect(OAuthClientToken.isExpired(token)).toBeTruthy();
     expect(client.getHttpClient().isTokenExpires()).toBeTruthy();
     await expect(client.getHttpClient().refreshToken())
         .rejects
-        .toHaveProperty('code', HttpClient_1.HttpClient.HTTP_UNAUTHORIZED);
+        .toHaveProperty('code', HttpClient.HTTP_UNAUTHORIZED);
     await expect(client.getUserEndpoint().getUser())
         .rejects
-        .toHaveProperty('code', HttpClient_1.HttpClient.HTTP_UNAUTHORIZED);
+        .toHaveProperty('code', HttpClient.HTTP_UNAUTHORIZED);
     // const user: User = await client.getUserEndpoint().getUser()
     // expect(user.email).toBe(passwordFlowUsername);
     //

package/dist/data.spec.js

@@ -1,6 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Client_1 = require("./Client");
+import { Client } from './Client';
 jest.setTimeout((60) * 1000);
 // const apiEndpoint: string = 'http://localhost:5728/';
 const apiEndpoint = 'https://api2.attlaz.com';
@@ -13,7 +11,7 @@ const passwordFlowPassword = 'koetjeboe';
 const tokenExpirationInSeconds = 5;
 test('Test get user', async () => {
     expect.assertions(1);
-    let client = new Client_1.Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
+    let client = new Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate();
     const user = await client.getUserEndpoint().getUser();
@@ -22,7 +20,7 @@ test('Test get user', async () => {
 });
 test('Test get project', async () => {
     expect.assertions(1);
-    let client = new Client_1.Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
+    let client = new Client(apiEndpoint, clientCredentialClientId, clientCredentialClientSecret);
     client.getHttpClient().enableDebug();
     await client.authenticate();
     const project = await client.getProjectEndpoint().getById('8B5C14EBB');