attlaz-client 1.4.20 → 1.4.23

package/dist/Model/Adapter/AdapterConnection.d.ts

@@ -1,11 +1,10 @@
+import { DataValueCollection } from '../DataValueCollection';
 export declare class AdapterConnection {
     id: number;
     key: string;
     adapter: string;
     name: string;
-    configuration: {
-        key: string;
-        value: string;
-    }[];
+    configuration: DataValueCollection;
+    constructor();
     static parse(rawAdapterConnection: any): AdapterConnection;
 }

package/dist/Model/Adapter/AdapterConnection.js

@@ -1,14 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdapterConnection = void 0;
+const DataValueCollection_1 = require("../DataValueCollection");
 class AdapterConnection {
+    constructor() {
+        this.configuration = new DataValueCollection_1.DataValueCollection();
+    }
     static parse(rawAdapterConnection) {
         let adapterConnection = new AdapterConnection();
         adapterConnection.id = rawAdapterConnection.id;
         adapterConnection.key = rawAdapterConnection.key;
         adapterConnection.adapter = rawAdapterConnection.adapter;
         adapterConnection.name = rawAdapterConnection.name;
-        adapterConnection.configuration = rawAdapterConnection.configuration;
+        adapterConnection.configuration = DataValueCollection_1.DataValueCollection.fromObject(rawAdapterConnection.configuration);
         return adapterConnection;
         // adapter.id = rawAdapter.id;
         // adapter.name = rawAdapter.name;

package/dist/Model/DataValue.d.ts

@@ -1,5 +1,6 @@
 export declare class DataValue {
     key: string;
     value: DataValueValue;
+    constructor(key: string, value: DataValueValue);
 }
 export declare type DataValueValue = string | number | boolean;

package/dist/Model/DataValue.js

@@ -2,5 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataValue = void 0;
 class DataValue {
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
 }
 exports.DataValue = DataValue;

package/dist/Model/DataValueCollection.d.ts

@@ -0,0 +1,13 @@
+import { DataValueValue } from './DataValue';
+export declare class DataValueCollection {
+    private values;
+    get length(): number;
+    static fromObject(rawTags: {
+        key: string;
+        value: DataValueValue;
+    }[]): DataValueCollection;
+    set(key: string, value: DataValueValue): void;
+    get(key: string): DataValueValue | null;
+    unset(key: string): void;
+    serialize(): string | null;
+}

package/dist/Model/DataValueCollection.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataValueCollection = void 0;
+const DataValue_1 = require("./DataValue");
+const Utils_1 = require("../Utils");
+class DataValueCollection {
+    constructor() {
+        this.values = [];
+    }
+    get length() {
+        return this.values.length;
+    }
+    static fromObject(rawTags) {
+        if (Utils_1.Utils.isNullOrUndefined(rawTags)) {
+            return new DataValueCollection();
+        }
+        const result = new DataValueCollection();
+        for (const rawTag of rawTags) {
+            // TODO: validate rawTag
+            result.set(rawTag.key, rawTag.value);
+        }
+        return result;
+    }
+    set(key, value) {
+        const existingIndex = this.values.findIndex((tag) => {
+            return tag.key === key;
+        });
+        if (existingIndex !== -1) {
+            this.values.splice(existingIndex);
+        }
+        this.values.push(new DataValue_1.DataValue(key, value));
+    }
+    get(key) {
+        for (const tag of this.values) {
+            if (tag.key === key) {
+                return tag.value;
+            }
+        }
+        return null;
+    }
+    unset(key) {
+        this.values = this.values.filter((tag) => {
+            return tag.key !== key;
+        });
+    }
+    serialize() {
+        if (this.values.length === 0) {
+            return null;
+        }
+        return JSON.stringify(this.values);
+    }
+}
+exports.DataValueCollection = DataValueCollection;

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

@@ -1,7 +1,7 @@
 import { LogLevel } from "./LogLevel";
 import { LogStreamId } from './LogStreamId';
-import { DataValue, DataValueValue } from '../DataValue';
 import { LogStatus } from './LogStatus';
+import { DataValueCollection } from '../DataValueCollection';
 export declare class Log {
     id: string;
     readonly logStream: LogStreamId;
@@ -10,10 +10,8 @@ export declare class Log {
     message: string;
     context: object;
     status: LogStatus;
-    tags: DataValue[];
+    tags: DataValueCollection;
     _version: string;
     constructor(logStream: LogStreamId, level: LogLevel, date: Date);
     static parse(rawLog: any): Log;
-    setTag(key: string, value: DataValueValue): void;
-    getTagValue(key: string): DataValueValue | null;
 }

package/dist/Model/Log/Log.js

@@ -4,13 +4,14 @@ exports.Log = void 0;
 const LogLevel_1 = require("./LogLevel");
 const LogStreamId_1 = require("./LogStreamId");
 const LogStatus_1 = require("./LogStatus");
+const DataValueCollection_1 = require("../DataValueCollection");
 class Log {
     constructor(logStream, level, date) {
         this.status = LogStatus_1.LogStatus.Normal;
-        this.tags = [];
         this.logStream = logStream;
         this.level = level;
         this.date = date;
+        this.tags = new DataValueCollection_1.DataValueCollection();
     }
     static parse(rawLog) {
         const date = new Date(rawLog.date);
@@ -23,20 +24,9 @@ class Log {
         if (rawLog.status !== null && rawLog.status !== undefined && rawLog.status !== '') {
             log.status = LogStatus_1.LogStatus.fromString(rawLog.status);
         }
-        log.tags = rawLog.tags;
+        log.tags = DataValueCollection_1.DataValueCollection.fromObject(rawLog.tags);
         log._version = rawLog._version;
         return log;
     }
-    setTag(key, value) {
-        this.tags.push({ key, value });
-    }
-    getTagValue(key) {
-        for (const tag of this.tags) {
-            if (tag.key === key) {
-                return tag.value;
-            }
-        }
-        return null;
-    }
 }
 exports.Log = Log;

package/dist/Model/Storage/StorageType.d.ts

@@ -2,7 +2,7 @@ export declare enum StorageType {
     Cache = "cache",
     Persistent = "persistent",
     Vault = "vault",
-    Workers = "workers"
+    Infrastructure = "infrastructure"
 }
 export declare namespace StorageType {
     function fromString(input: string): StorageType;

package/dist/Model/Storage/StorageType.js

@@ -7,7 +7,7 @@ var StorageType;
     StorageType["Cache"] = "cache";
     StorageType["Persistent"] = "persistent";
     StorageType["Vault"] = "vault";
-    StorageType["Workers"] = "workers";
+    StorageType["Infrastructure"] = "infrastructure";
 })(StorageType = exports.StorageType || (exports.StorageType = {}));
 (function (StorageType) {
     function fromString(input) {

package/dist/Service/AdapterEndpoint.d.ts

@@ -9,4 +9,5 @@ export declare class AdapterEndpoint extends Endpoint {
     getAdapterConfiguration(adapterId: string): Promise<DataResult<AdapterConfiguration[]>>;
     getConnections(projectId: string): Promise<DataResult<AdapterConnection[]>>;
     getConnectionByKey(connectionKey: string): Promise<DataResult<AdapterConnection>>;
+    saveConnection(projectId: string, adapter: AdapterConnection): Promise<DataResult<AdapterConnection>>;
 }

package/dist/Service/AdapterEndpoint.js

@@ -76,5 +76,21 @@ class AdapterEndpoint extends Endpoint_1.Endpoint {
             throw error;
         }
     }
+    async saveConnection(projectId, adapter) {
+        try {
+            let url = '/connections';
+            const data = adapter;
+            data.projectId = projectId;
+            const result = await this.request(url, data, 'POST');
+            result.setData(AdapterConnection_1.AdapterConnection.parse(result.getData()));
+            return result;
+        }
+        catch (error) {
+            if (this.httpClient.isDebugEnabled()) {
+                console.error('Failed to save connection: ', error);
+            }
+            throw error;
+        }
+    }
 }
 exports.AdapterEndpoint = AdapterEndpoint;

package/dist/Service/LogEndpoint.js

@@ -55,7 +55,7 @@ class LogEndpoint extends Endpoint_1.Endpoint {
         return new Promise((resolve, reject) => {
             let cmd = '/logstreams/' + Utils_1.Utils.base64encode(log.logStream.id) + '/logs';
             this.httpClient.request(cmd, log, 'POST').then((rawSavedLog) => {
-                resolve(Log_1.Log.parse(rawSavedLog));
+                resolve(Log_1.Log.parse(rawSavedLog.getData()));
             }).catch((reason) => {
                 if (this.httpClient.isDebugEnabled()) {
                     console.error('Failed to save log: ', reason);

package/package.json

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