@hahnpro/hpc-api 4.1.0 → 4.1.2

package/dist/asset.service.js

@@ -15,7 +15,7 @@ class AssetService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/assets');
         this.addAttachment = (id, form) => {
-            const headers = { ...form.getHeaders() };
+            const headers = Object.assign({}, form.getHeaders());
             return this.httpClient.post(`${this.basePath}/${id}/attachment`, form, {
                 headers,
                 maxBodyLength: Infinity,

package/dist/content.service.js

@@ -16,33 +16,35 @@ class ContentService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/contents');
         this.upload = (form) => {
-            const headers = { ...form.getHeaders() };
+            const headers = Object.assign({}, form.getHeaders());
             return this.httpClient.post(`${this.basePath}`, form, { headers, maxBodyLength: Infinity, maxContentLength: Infinity });
         };
     }
-    async download(id, second) {
-        let returnType;
-        if (typeof second === 'boolean' || second == null) {
-            returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
-        }
-        else {
-            returnType = second;
-        }
-        const url = `${this.basePath}/${id}/download`;
-        switch (returnType) {
-            case content_interface_1.ReturnType.TEXT:
-                return this.httpClient.get(url, { responseType: 'text' });
-            case content_interface_1.ReturnType.JSON:
-                return this.httpClient.get(url, { responseType: 'json' });
-            case content_interface_1.ReturnType.NODEBUFFER:
-                return Buffer.from(new Uint8Array(await this.httpClient.get(url, { responseType: 'arraybuffer' })));
-            case content_interface_1.ReturnType.BLOB:
-                return this.httpClient.get(url, { responseType: 'blob' });
-            case content_interface_1.ReturnType.ARRAYBUFFER:
-                return this.httpClient.get(url, { responseType: 'arraybuffer' });
-            case content_interface_1.ReturnType.NODESTREAM:
-                return this.httpClient.get(url, { responseType: 'stream' });
-        }
+    download(id, second) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let returnType;
+            if (typeof second === 'boolean' || second == null) {
+                returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
+            }
+            else {
+                returnType = second;
+            }
+            const url = `${this.basePath}/${id}/download`;
+            switch (returnType) {
+                case content_interface_1.ReturnType.TEXT:
+                    return this.httpClient.get(url, { responseType: 'text' });
+                case content_interface_1.ReturnType.JSON:
+                    return this.httpClient.get(url, { responseType: 'json' });
+                case content_interface_1.ReturnType.NODEBUFFER:
+                    return Buffer.from(new Uint8Array(yield this.httpClient.get(url, { responseType: 'arraybuffer' })));
+                case content_interface_1.ReturnType.BLOB:
+                    return this.httpClient.get(url, { responseType: 'blob' });
+                case content_interface_1.ReturnType.ARRAYBUFFER:
+                    return this.httpClient.get(url, { responseType: 'arraybuffer' });
+                case content_interface_1.ReturnType.NODESTREAM:
+                    return this.httpClient.get(url, { responseType: 'stream' });
+            }
+        });
     }
 }
 exports.ContentService = ContentService;

package/dist/flow-deployment.service.js

@@ -33,7 +33,8 @@ class FlowDeploymentService extends BaseService {
         return this.httpClient.get(`${this.basePath}/${id}/logs`);
     }
     resolveReferences(id, recursive = true, types) {
-        const params = { recursive, types: types?.join(',') ?? undefined };
+        var _a;
+        const params = { recursive, types: (_a = types === null || types === void 0 ? void 0 : types.join(',')) !== null && _a !== void 0 ? _a : undefined };
         return this.httpClient.get(`${this.basePath}/${id}/references`, { params });
     }
     updateStatus(id, desiredStatus) {
@@ -42,15 +43,17 @@ class FlowDeploymentService extends BaseService {
     deleteOne(id) {
         return this.updateStatus(id, 'deleted');
     }
-    async waitForRunningStatus(id) {
-        return new Promise(async (resolve, reject) => {
-            const esId = await this.subscribeToStatus(id, (event) => {
-                if (event.type === 'message' &&
-                    ['running', 'deployment failed', 'deleted', 'generating failed', 'updating failed', 'upgrading failed'].includes(event.data)) {
-                    this.httpClient.destroyEventSource(esId);
-                    event.data === 'running' ? resolve() : reject(`Deployment in failed status: ${event.data}`);
-                }
-            });
+    waitForRunningStatus(id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const esId = yield this.subscribeToStatus(id, (event) => {
+                    if (event.type === 'message' &&
+                        ['running', 'deployment failed', 'deleted', 'generating failed', 'updating failed', 'upgrading failed'].includes(event.data)) {
+                        this.httpClient.destroyEventSource(esId);
+                        event.data === 'running' ? resolve() : reject(`Deployment in failed status: ${event.data}`);
+                    }
+                });
+            }));
         });
     }
     addOne(dto) {

package/dist/flow-module.service.js

@@ -11,7 +11,7 @@ class FlowModuleService extends data_service_1.DataService {
     }
     publish(form) {
         const config = {
-            headers: { ...form.getHeaders() },
+            headers: Object.assign({}, form.getHeaders()),
             maxBodyLength: Infinity,
             maxContentLength: Infinity,
         };

package/dist/flow.service.js

@@ -33,11 +33,13 @@ class FlowService extends BaseService {
     getDiagramRevisions(id) {
         return this.httpClient.get(`${this.basePath}/${id}/diagram/revisions`);
     }
-    async isDeploymentOnLatestDiagramVersion(depl) {
-        const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
-        const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
-        const revisions = await this.getDiagramRevisions(flowId);
-        return revisions[revisions.length - 1].id === diagramId;
+    isDeploymentOnLatestDiagramVersion(depl) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
+            const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
+            const revisions = yield this.getDiagramRevisions(flowId);
+            return revisions[revisions.length - 1].id === diagramId;
+        });
     }
     getRevisions(id) {
         return this.httpClient.get(`${this.basePath}/${id}/revisions`);

package/dist/http.service.js

@@ -17,7 +17,7 @@ class HttpClient {
         this.clientId = clientId;
         this.clientSecret = clientSecret;
         this.eventSourcesMap = new Map();
-        this.getQueueStats = () => this.requestQueue?.getStats();
+        this.getQueueStats = () => { var _a; return (_a = this.requestQueue) === null || _a === void 0 ? void 0 : _a.getStats(); };
         this.delete = (url, config) => this.request('DELETE', url, config);
         this.get = (url, config) => this.request('GET', url, config);
         this.post = (url, data, config) => this.request('POST', url, config, data);
@@ -26,37 +26,39 @@ class HttpClient {
             return this.requestQueue.add(() => new Promise((resolve, reject) => {
                 this.getAccessToken()
                     .then((token) => {
-                    const headers = { Authorization: `Bearer ${token}`, ...config.headers };
-                    return this.axiosInstance.request({ ...config, headers, method, url, data });
+                    const headers = Object.assign({ Authorization: `Bearer ${token}` }, config.headers);
+                    return this.axiosInstance.request(Object.assign(Object.assign({}, config), { headers, method, url, data }));
                 })
                     .then((response) => resolve(response.data))
                     .catch(reject);
             }));
         };
-        this.getAccessToken = async (forceRefresh = false) => {
+        this.getAccessToken = (forceRefresh = false) => tslib_1.__awaiter(this, void 0, void 0, function* () {
             if (forceRefresh || !this.tokenSet || this.tokenSet.isExpired()) {
                 return this.requestAccessToken();
             }
             return this.tokenSet.accessToken;
-        };
+        });
         this.axiosInstance = axios_1.default.create({ baseURL, timeout: 60000 });
         this.authAxiosInstance = axios_1.default.create({ baseURL: authBaseURL || baseURL, timeout: 10000 });
         this.requestQueue = new Queue_1.Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
     }
-    async addEventSource(url, listener, errorListener) {
-        const id = (0, uuid_1.v4)();
-        const errListener = errorListener
-            ? errorListener
-            : (event) => {
-                throw new Error(JSON.stringify(event, null, 2));
-            };
-        const es = new eventsource_1.default(`${this.baseURL}${url}`, {
-            headers: { authorization: 'Bearer ' + (await this.getAccessToken()) },
+    addEventSource(url, listener, errorListener) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const id = (0, uuid_1.v4)();
+            const errListener = errorListener
+                ? errorListener
+                : (event) => {
+                    throw new Error(JSON.stringify(event, null, 2));
+                };
+            const es = new eventsource_1.default(`${this.baseURL}${url}`, {
+                headers: { authorization: 'Bearer ' + (yield this.getAccessToken()) },
+            });
+            es.addEventListener('message', listener);
+            es.addEventListener('error', errListener);
+            this.eventSourcesMap.set(id, { eventSource: es, listener, errListener });
+            return id;
         });
-        es.addEventListener('message', listener);
-        es.addEventListener('error', errListener);
-        this.eventSourcesMap.set(id, { eventSource: es, listener, errListener });
-        return id;
     }
     destroyEventSource(id) {
         if (!this.eventSourcesMap.has(id)) {
@@ -74,58 +76,63 @@ class HttpClient {
         }
     }
     validateIssuer(issuer) {
+        var _a, _b;
         if (!issuer.issuer ||
-            !issuer.grant_types_supported?.includes('client_credentials') ||
-            !issuer.token_endpoint_auth_methods_supported?.includes('client_secret_jwt')) {
+            !((_a = issuer.grant_types_supported) === null || _a === void 0 ? void 0 : _a.includes('client_credentials')) ||
+            !((_b = issuer.token_endpoint_auth_methods_supported) === null || _b === void 0 ? void 0 : _b.includes('client_secret_jwt'))) {
             throw new Error('Issuer does not support client_secret_jwt');
         }
         return issuer;
     }
-    async discoverIssuer(uri) {
-        const wellKnownUri = `${uri}/.well-known/openid-configuration`;
-        const issuerResponse = await this.authAxiosInstance.get(wellKnownUri, {
-            responseType: 'json',
-            headers: { Accept: 'application/json' },
+    discoverIssuer(uri) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const wellKnownUri = `${uri}/.well-known/openid-configuration`;
+            const issuerResponse = yield this.authAxiosInstance.get(wellKnownUri, {
+                responseType: 'json',
+                headers: { Accept: 'application/json' },
+            });
+            return this.validateIssuer(issuerResponse.data);
         });
-        return this.validateIssuer(issuerResponse.data);
     }
-    async requestAccessToken() {
-        const issuer = await this.discoverIssuer(`${this.authBaseURL}/realms/${this.realm}`);
-        const timestamp = Date.now() / 1000;
-        const audience = [...new Set([issuer.issuer, issuer.token_endpoint].filter(Boolean))];
-        const assertionPayload = {
-            iat: timestamp,
-            exp: timestamp + 60,
-            jti: (0, uuid_1.v4)(),
-            iss: this.clientId,
-            sub: this.clientId,
-            aud: audience,
-        };
-        const supportedAlgos = issuer.token_endpoint_auth_signing_alg_values_supported;
-        const alg = issuer.token_endpoint_auth_signing_alg ??
-            (Array.isArray(supportedAlgos) && supportedAlgos.find((signAlg) => /^HS(?:256|384|512)/.test(signAlg)));
-        if (!alg) {
-            throw new Error('Issuer has to support HS256, HS384 or HS512');
-        }
-        const assertion = await new jose_1.CompactSign(Buffer.from(JSON.stringify(assertionPayload)))
-            .setProtectedHeader({ alg })
-            .sign(new TextEncoder().encode(this.clientSecret));
-        const opts = {
-            client_id: this.clientId,
-            client_assertion: assertion,
-            client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
-            grant_type: 'client_credentials',
-        };
-        const authResponse = await this.authAxiosInstance.post(issuer.token_endpoint, (0, querystring_1.stringify)(opts), {
-            headers: { Accept: 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' },
+    requestAccessToken() {
+        var _a, _b;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const issuer = yield this.discoverIssuer(`${this.authBaseURL}/realms/${this.realm}`);
+            const timestamp = Date.now() / 1000;
+            const audience = [...new Set([issuer.issuer, issuer.token_endpoint].filter(Boolean))];
+            const assertionPayload = {
+                iat: timestamp,
+                exp: timestamp + 60,
+                jti: (0, uuid_1.v4)(),
+                iss: this.clientId,
+                sub: this.clientId,
+                aud: audience,
+            };
+            const supportedAlgos = issuer.token_endpoint_auth_signing_alg_values_supported;
+            const alg = (_a = issuer.token_endpoint_auth_signing_alg) !== null && _a !== void 0 ? _a : (Array.isArray(supportedAlgos) && supportedAlgos.find((signAlg) => /^HS(?:256|384|512)/.test(signAlg)));
+            if (!alg) {
+                throw new Error('Issuer has to support HS256, HS384 or HS512');
+            }
+            const assertion = yield new jose_1.CompactSign(Buffer.from(JSON.stringify(assertionPayload)))
+                .setProtectedHeader({ alg })
+                .sign(new TextEncoder().encode(this.clientSecret));
+            const opts = {
+                client_id: this.clientId,
+                client_assertion: assertion,
+                client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
+                grant_type: 'client_credentials',
+            };
+            const authResponse = yield this.authAxiosInstance.post(issuer.token_endpoint, (0, querystring_1.stringify)(opts), {
+                headers: { Accept: 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' },
+            });
+            if (((_b = authResponse === null || authResponse === void 0 ? void 0 : authResponse.data) === null || _b === void 0 ? void 0 : _b.access_token) && authResponse.data.expires_in) {
+                this.tokenSet = new token_set_1.TokenSet(authResponse.data.access_token, authResponse.data.expires_in);
+                return authResponse.data.access_token;
+            }
+            else {
+                throw new Error('Invalid access token received');
+            }
         });
-        if (authResponse?.data?.access_token && authResponse.data.expires_in) {
-            this.tokenSet = new token_set_1.TokenSet(authResponse.data.access_token, authResponse.data.expires_in);
-            return authResponse.data.access_token;
-        }
-        else {
-            throw new Error('Invalid access token received');
-        }
     }
 }
 exports.HttpClient = HttpClient;

package/dist/mock/api.mock.js

@@ -38,30 +38,16 @@ class MockAPI {
                     uiSchema: {},
                 };
         });
-        const assets1 = assets.map((v, index) => ({
-            ...v,
-            readPermissions: [],
-            readWritePermissions: [],
-            type: assetTypes[index],
-        }));
-        const assetRevisions1 = assetRevisions.map((v, index) => ({
-            ...v,
-            readPermissions: [],
-            readWritePermissions: [],
-            type: assetTypes[index],
-        }));
-        const contents1 = contents.map((v) => ({
-            ...v,
-            readPermissions: [],
-            readWritePermissions: [],
-            size: 0,
-            fileId: '',
-            mimetype: v.mimetype || '',
-        }));
+        const assets1 = assets.map((v, index) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], type: assetTypes[index] })));
+        const assetRevisions1 = assetRevisions.map((v, index) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], type: assetTypes[index] })));
+        const contents1 = contents.map((v) => {
+            var _a;
+            return (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], size: 0, fileId: '', mimetype: (_a = v.mimetype) !== null && _a !== void 0 ? _a : '' }));
+        });
         const contentData = contents.map((v) => {
             return v.data ? v.data : (0, fs_1.readFileSync)((0, path_1.join)(v.filePath, v.filename));
         });
-        const secrets1 = secrets.map((v) => ({ ...v, readPermissions: [], readWritePermissions: [] }));
+        const secrets1 = secrets.map((v) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [] })));
         const timeSeries1 = timeSeries.map((value) => ({
             id: value.id,
             name: value.name,
@@ -116,77 +102,22 @@ class MockAPI {
             createdAt: v.createdAt,
         }));
         const timeseriesValues = timeSeries.map((v) => v.values);
-        const diagrams1 = diagrams.map((v) => ({
-            ...v,
-            json: '',
-            author: 'nobody',
-        }));
-        const flows1 = flows.map((v) => ({
-            ...v,
-            readPermissions: [],
-            readWritePermissions: [],
-            diagram: diagrams.find((v1) => v1.flow === v.id).id,
-            name: `flow-${v.id}`,
-            deployments: [],
-        }));
-        const flowRevisions1 = flowRevisions.map((v) => ({
-            ...v,
-            readPermissions: [],
-            readWritePermissions: [],
-            diagram: diagrams.find((v1) => v1.flow === v.originalId).id,
-            name: `flow-${v.id}`,
-            deployments: [],
-        }));
-        const deployments1 = deployments.map((v) => ({
-            ...v,
-            readPermissions: [],
-            readWritePermissions: [],
-            diagram: v.diagram ?? '',
-            artifact: null,
-            flowModel: { connections: [], elements: [] },
-            desiredStatus: 'running',
-            actualStatus: 'generating queued',
-            target: 'executor',
-            name: `deployment-${v.id}`,
-        }));
-        const functions1 = functions.map((v) => ({
-            ...v,
-            category: 'task',
-            readPermissions: [],
-            readWritePermissions: [],
-            author: 'nobody',
-        }));
-        const functionRevisions1 = functionRevisions.map((v) => ({
-            ...v,
-            category: 'task',
-            readPermissions: [],
-            readWritePermissions: [],
-            author: 'nobody',
-        }));
-        const modules1 = modules.map((v, index) => ({
-            ...v,
-            artifacts: modules[index].artifacts.map((art) => ({
-                ...art,
-                version: '0.0.0',
-                id: (0, crypto_1.randomUUID)(),
-                mimetype: '',
-                size: 0,
-                createdAt: '' + Date.now(),
-            })) ?? [],
-            author: 'nobody',
-            functions: [],
-            readPermissions: [],
-            readWritePermissions: [],
-        }));
-        const labels1 = labels.map((label) => ({
-            ...label,
-            color: '',
-            description: '',
-            readPermissions: [],
-            readWritePermissions: [],
-        }));
-        const vaultSecrets1 = vault.map((v) => ({ ...v, readPermissions: [], readWritePermissions: [] }));
-        const notifications1 = notifications.map((n) => ({ ...n, link: '', description: '', read: false }));
+        const diagrams1 = diagrams.map((v) => (Object.assign(Object.assign({}, v), { json: '', author: 'nobody' })));
+        const flows1 = flows.map((v) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], diagram: diagrams.find((v1) => v1.flow === v.id).id, name: `flow-${v.id}`, deployments: [] })));
+        const flowRevisions1 = flowRevisions.map((v) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], diagram: diagrams.find((v1) => v1.flow === v.originalId).id, name: `flow-${v.id}`, deployments: [] })));
+        const deployments1 = deployments.map((v) => {
+            var _a;
+            return (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], diagram: (_a = v.diagram) !== null && _a !== void 0 ? _a : '', artifact: null, flowModel: { connections: [], elements: [] }, desiredStatus: 'running', actualStatus: 'generating queued', target: 'executor', name: `deployment-${v.id}` }));
+        });
+        const functions1 = functions.map((v) => (Object.assign(Object.assign({}, v), { category: 'task', readPermissions: [], readWritePermissions: [], author: 'nobody' })));
+        const functionRevisions1 = functionRevisions.map((v) => (Object.assign(Object.assign({}, v), { category: 'task', readPermissions: [], readWritePermissions: [], author: 'nobody' })));
+        const modules1 = modules.map((v, index) => {
+            var _a;
+            return (Object.assign(Object.assign({}, v), { artifacts: (_a = modules[index].artifacts.map((art) => (Object.assign(Object.assign({}, art), { version: '0.0.0', id: (0, crypto_1.randomUUID)(), mimetype: '', size: 0, createdAt: '' + Date.now() })))) !== null && _a !== void 0 ? _a : [], author: 'nobody', functions: [], readPermissions: [], readWritePermissions: [] }));
+        });
+        const labels1 = labels.map((label) => (Object.assign(Object.assign({}, label), { color: '', description: '', readPermissions: [], readWritePermissions: [] })));
+        const vaultSecrets1 = vault.map((v) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [] })));
+        const notifications1 = notifications.map((n) => (Object.assign(Object.assign({}, n), { link: '', description: '', read: false })));
         this.assets = new asset_mock_service_1.AssetMockService(this, assets1, assetRevisions1);
         this.contents = new content_mock_service_1.ContentMockService(contents1, contentData);
         this.endpoints = new endpoint_mock_service_1.EndpointMockService(endpoint1);

package/dist/mock/asset.mock.service.js

@@ -27,12 +27,12 @@ class AssetMockService extends BaseService {
         return page;
     }
     addOne(dto) {
-        this.revisions.push({ ...dto, originalId: dto.id });
+        this.revisions.push(Object.assign(Object.assign({}, dto), { originalId: dto.id }));
         return super.addOne(dto);
     }
     deleteOne(assetId, force = false) {
         const asset = this.data.find((v) => v.id === assetId);
-        if (!asset?.deletedAt && !force) {
+        if (!(asset === null || asset === void 0 ? void 0 : asset.deletedAt) && !force) {
             asset.deletedAt = new Date().toISOString();
             return Promise.resolve(asset);
         }
@@ -48,31 +48,40 @@ class AssetMockService extends BaseService {
         const page = this.getAssets(params, false);
         return Promise.resolve(page);
     }
-    async updateOne(assetId, dto) {
-        await super.deleteOne(assetId);
-        const asset = await this.addOne(dto);
-        return Promise.resolve(asset);
+    updateOne(assetId, dto) {
+        const _super = Object.create(null, {
+            deleteOne: { get: () => super.deleteOne }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield _super.deleteOne.call(this, assetId);
+            const asset = yield this.addOne(dto);
+            return Promise.resolve(asset);
+        });
     }
-    async addAttachment(id, form) {
-        const asset = this.data.find((v) => v.id === id);
-        const content = await this.api.contents.upload(form);
-        asset.attachments.push(content.id);
-        return Promise.resolve(asset);
+    addAttachment(id, form) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const asset = this.data.find((v) => v.id === id);
+            const content = yield this.api.contents.upload(form);
+            asset.attachments.push(content.id);
+            return Promise.resolve(asset);
+        });
     }
-    async getAttachments(assetId) {
-        const contents = await this.api.contents.getMany();
-        const docs = contents.docs.filter((c) => c.assets?.includes?.(assetId));
-        return { docs, total: docs.length, limit: 0 };
+    getAttachments(assetId) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const contents = yield this.api.contents.getMany();
+            const docs = contents.docs.filter((c) => { var _a, _b; return (_b = (_a = c.assets) === null || _a === void 0 ? void 0 : _a.includes) === null || _b === void 0 ? void 0 : _b.call(_a, assetId); });
+            return { docs, total: docs.length, limit: 0 };
+        });
     }
     getChildren(assetId, params = {}) {
         return this.getManyFiltered({ parent: assetId }, params);
     }
     getEventLevelOverride(ids, causes) {
         const eventCausesAssets = this.data.filter((v) => v.name.startsWith('hpc-event-causes-'));
-        return Promise.resolve(ids.reduce((acc, id) => ({
-            ...acc,
-            [id]: eventCausesAssets.find((v) => v.name.includes(id))?.data ?? {},
-        }), {}));
+        return Promise.resolve(ids.reduce((acc, id) => {
+            var _a, _b;
+            return (Object.assign(Object.assign({}, acc), { [id]: (_b = (_a = eventCausesAssets.find((v) => v.name.includes(id))) === null || _a === void 0 ? void 0 : _a.data) !== null && _b !== void 0 ? _b : {} }));
+        }, {}));
     }
     updateEventCausesAsset(id, dto) {
         const asset = this.data.find((v) => v.id === id);

package/dist/mock/assetTypes.mock.service.js

@@ -23,12 +23,12 @@ class AssetTypesMockService extends BaseService {
     }
     addOne(dto) {
         const id = (0, crypto_1.randomUUID)();
-        this.revisions.push({ ...dto, id, originalId: dto.id });
+        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.id }));
         return super.addOne(dto);
     }
     deleteOne(id, force = false) {
         const assettype = this.data.find((v) => v.id === id);
-        if (!assettype?.deletedAt && !force) {
+        if (!(assettype === null || assettype === void 0 ? void 0 : assettype.deletedAt) && !force) {
             assettype.deletedAt = new Date().toISOString();
             return Promise.resolve(assettype);
         }
@@ -40,10 +40,15 @@ class AssetTypesMockService extends BaseService {
         });
         return super.deleteOne(id);
     }
-    async updateOne(id, dto) {
-        await super.deleteOne(id);
-        const assetType = await this.addOne(dto);
-        return Promise.resolve(assetType);
+    updateOne(id, dto) {
+        const _super = Object.create(null, {
+            deleteOne: { get: () => super.deleteOne }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield _super.deleteOne.call(this, id);
+            const assetType = yield this.addOne(dto);
+            return Promise.resolve(assetType);
+        });
     }
     getRevisions(id) {
         const revisions = this.revisions.filter((revision) => revision.originalId === id);

package/dist/mock/content.mock.service.js

@@ -67,7 +67,7 @@ class ContentMockService extends BaseService {
     }
     deleteOne(contentId, force = false) {
         const content = this.data.find((v) => v.id === contentId);
-        if (!content?.deletedAt && !force) {
+        if (!(content === null || content === void 0 ? void 0 : content.deletedAt) && !force) {
             content.deletedAt = new Date().toISOString();
             return Promise.resolve(content);
         }

package/dist/mock/data.mock.service.js

@@ -1,15 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataMockService = void 0;
+const tslib_1 = require("tslib");
 const data_service_1 = require("../data.service");
 class DataMockService extends data_service_1.DataService {
     constructor() {
         super(null, null);
         this.data = [];
     }
-    async addMany(dto) {
-        const map = dto.map((v) => this.addOne(v));
-        return Promise.all(map);
+    addMany(dto) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const map = dto.map((v) => this.addOne(v));
+            return Promise.all(map);
+        });
     }
     addOne(dto) {
         this.data.push(dto);
@@ -30,25 +33,29 @@ class DataMockService extends data_service_1.DataService {
         };
         return Promise.resolve(page);
     }
-    async getManyFiltered(filter, params = {}) {
-        const paginated = await this.getMany(params);
-        const newData = paginated.docs.filter((v) => filter.parent === v.parent || filter.tags?.some((tag) => v.tags?.contains(tag)) || filter.type === v.tag);
-        const page = {
-            docs: newData,
-            limit: paginated.limit || Number.MAX_SAFE_INTEGER,
-            total: newData.length,
-        };
-        return Promise.resolve(page);
+    getManyFiltered(filter, params = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const paginated = yield this.getMany(params);
+            const newData = paginated.docs.filter((v) => { var _a; return filter.parent === v.parent || ((_a = filter.tags) === null || _a === void 0 ? void 0 : _a.some((tag) => { var _a; return (_a = v.tags) === null || _a === void 0 ? void 0 : _a.contains(tag); })) || filter.type === v.tag; });
+            const page = {
+                docs: newData,
+                limit: paginated.limit || Number.MAX_SAFE_INTEGER,
+                total: newData.length,
+            };
+            return Promise.resolve(page);
+        });
     }
     getOne(id, options = {}) {
         const idKey = options.idKey || 'id';
         const t = this.data.find((v) => v[idKey] === id);
         return Promise.resolve(t);
     }
-    async updateOne(id, dto) {
-        await this.deleteOne(id);
-        const t = await this.addOne(dto);
-        return Promise.resolve(t);
+    updateOne(id, dto) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield this.deleteOne(id);
+            const t = yield this.addOne(dto);
+            return Promise.resolve(t);
+        });
     }
 }
 exports.DataMockService = DataMockService;

package/dist/mock/flow-deployment.mock.service.js

@@ -25,19 +25,26 @@ class FlowDeploymentMockService extends BaseService {
         listener(new MessageEvent('message', { data: 'foo' }));
         return Promise.resolve((0, crypto_1.randomUUID)());
     }
-    async waitForRunningStatus(id) {
-        const flowDeployment = this.data.find((v) => v.id === id);
-        flowDeployment.actualStatus = 'running';
+    waitForRunningStatus(id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const flowDeployment = this.data.find((v) => v.id === id);
+            flowDeployment.actualStatus = 'running';
+        });
     }
-    async updateStatus(id, desiredStatus) {
-        const deployment = await this.getOne(id);
-        deployment.desiredStatus = desiredStatus;
-        deployment.actualStatus = desiredStatus;
-        return Promise.resolve(deployment);
+    updateStatus(id, desiredStatus) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const deployment = yield this.getOne(id);
+            deployment.desiredStatus = desiredStatus;
+            deployment.actualStatus = desiredStatus;
+            return Promise.resolve(deployment);
+        });
     }
-    async resolveReferences(id, recursive, types) {
-        const depl = await this.getOne(id);
-        return depl.refs ?? [];
+    resolveReferences(id, recursive, types) {
+        var _a;
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const depl = yield this.getOne(id);
+            return (_a = depl.refs) !== null && _a !== void 0 ? _a : [];
+        });
     }
     getDeploymentStatistics(id) {
         return Promise.resolve({
@@ -64,58 +71,72 @@ class FlowDeploymentMockService extends BaseService {
             },
         });
     }
-    async getDeploymentLogs(id) {
-        const depl = await this.getOne(id);
-        return Promise.resolve([
-            {
-                type: 'flow.log.info',
-                deploymentId: id,
-                subject: 'FlowApplication',
-                data: 'Flow Deployment is running',
-                '@timestamp': '2022-03-23T09:14:03.129Z',
-                eventId: 'c68b7674-b8da-46c5-85f0-8e4279d74a78',
-                datacontenttype: 'text/plain',
-                elementId: 'none',
-                time: '2022-03-23T09:14:03.129Z',
-                flowId: depl.flow,
-            },
-        ]);
+    getDeploymentLogs(id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const depl = yield this.getOne(id);
+            return Promise.resolve([
+                {
+                    type: 'flow.log.info',
+                    deploymentId: id,
+                    subject: 'FlowApplication',
+                    data: 'Flow Deployment is running',
+                    '@timestamp': '2022-03-23T09:14:03.129Z',
+                    eventId: 'c68b7674-b8da-46c5-85f0-8e4279d74a78',
+                    datacontenttype: 'text/plain',
+                    elementId: 'none',
+                    time: '2022-03-23T09:14:03.129Z',
+                    flowId: depl.flow,
+                },
+            ]);
+        });
     }
-    async addOne(dto) {
-        const flow = await this.api.flows.getFlowWithDiagram(dto.diagramId);
-        const refs = await this.getReferences(dto.properties);
-        const id = (0, crypto_1.randomUUID)();
-        const newDepl = {
-            actualStatus: 'generating queued',
-            artifact: undefined,
-            desiredStatus: 'running',
-            diagram: dto.diagramId,
-            flow: flow.id,
-            flowModel: { elements: [], connections: [], properties: dto.properties },
-            id,
-            name: dto.name,
-            readPermissions: [],
-            readWritePermissions: [],
-            target: 'executor',
-            refs,
-        };
-        await this.api.flows.updateOne(flow.id, { ...flow, deployments: [...flow.deployments, id] });
-        return super.addOne(newDepl);
+    addOne(dto) {
+        const _super = Object.create(null, {
+            addOne: { get: () => super.addOne }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const flow = yield this.api.flows.getFlowWithDiagram(dto.diagramId);
+            const refs = yield this.getReferences(dto.properties);
+            const id = (0, crypto_1.randomUUID)();
+            const newDepl = {
+                actualStatus: 'generating queued',
+                artifact: undefined,
+                desiredStatus: 'running',
+                diagram: dto.diagramId,
+                flow: flow.id,
+                flowModel: { elements: [], connections: [], properties: dto.properties },
+                id,
+                name: dto.name,
+                readPermissions: [],
+                readWritePermissions: [],
+                target: 'executor',
+                refs,
+            };
+            yield this.api.flows.updateOne(flow.id, Object.assign(Object.assign({}, flow), { deployments: [...flow.deployments, id] }));
+            return _super.addOne.call(this, newDepl);
+        });
     }
-    async deleteOne(id) {
-        const depl = await this.getOne(id);
-        const flow = await this.api.flows.getOne(depl.flow);
-        const index = flow.deployments.findIndex((v) => v === id);
-        flow.deployments.splice(index, 1);
-        await this.api.flows.updateOne(flow.id, flow);
-        return super.deleteOne(id);
+    deleteOne(id) {
+        const _super = Object.create(null, {
+            deleteOne: { get: () => super.deleteOne }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const depl = yield this.getOne(id);
+            const flow = yield this.api.flows.getOne(depl.flow);
+            const index = flow.deployments.findIndex((v) => v === id);
+            flow.deployments.splice(index, 1);
+            yield this.api.flows.updateOne(flow.id, flow);
+            return _super.deleteOne.call(this, id);
+        });
     }
-    async getReferences(properties) {
-        return Promise.all(Object.keys(properties).map(async (prop) => {
-            if (prop !== 'assetId')
-                throw new Error('not implemented');
-            return { id: (await this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
-        }));
+    getReferences(properties) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return Promise.all(Object.keys(properties).map((prop) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                if (prop !== 'assetId')
+                    throw new Error('not implemented');
+                return { id: (yield this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
+            })));
+        });
     }
 }
 exports.FlowDeploymentMockService = FlowDeploymentMockService;

package/dist/mock/flow-functions.mock.service.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowFunctionsMockService = void 0;
+const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
 const data_mock_service_1 = require("./data.mock.service");
 class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
@@ -11,7 +12,7 @@ class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
     }
     addOne(dto) {
         const id = (0, crypto_1.randomUUID)();
-        this.revisions.push({ ...dto, id, originalId: dto.fqn });
+        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.fqn }));
         return super.addOne(dto);
     }
     deleteOne(fqn) {
@@ -25,18 +26,22 @@ class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
         });
         return Promise.resolve(undefined);
     }
-    async updateOne(fqn, dto) {
-        const index = this.data.findIndex((v) => v.fqn === fqn);
-        this.data.splice(index, 1);
-        const flowFunction = await this.addOne(dto);
-        return Promise.resolve(flowFunction);
+    updateOne(fqn, dto) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const index = this.data.findIndex((v) => v.fqn === fqn);
+            this.data.splice(index, 1);
+            const flowFunction = yield this.addOne(dto);
+            return Promise.resolve(flowFunction);
+        });
     }
     getOne(fqn, options) {
         const t = this.data.find((v) => v.fqn === fqn);
         return Promise.resolve(t);
     }
-    async getOneById(id) {
-        return this.data.find((v) => v.id === id);
+    getOneById(id) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return this.data.find((v) => v.id === id);
+        });
     }
     getRevisions(fqn) {
         const revisions = this.revisions.filter((revision) => revision.originalId === fqn);

package/dist/mock/flow-modules.mock.service.js

@@ -1,17 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowModulesMockService = void 0;
+const tslib_1 = require("tslib");
 const data_mock_service_1 = require("./data.mock.service");
 class FlowModulesMockService extends data_mock_service_1.DataMockService {
     constructor(modules) {
         super();
         this.data = modules;
     }
-    async deleteArtifact(name, version) {
-        const module = await this.getOne(name);
-        const index = module.artifacts.findIndex((art) => art.version === version);
-        module.artifacts.splice(index, 1);
-        return Promise.resolve(module);
+    deleteArtifact(name, version) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const module = yield this.getOne(name);
+            const index = module.artifacts.findIndex((art) => art.version === version);
+            module.artifacts.splice(index, 1);
+            return Promise.resolve(module);
+        });
     }
     publish(form) {
         return Promise.resolve(undefined);

package/dist/mock/flow.mock.service.js

@@ -20,7 +20,7 @@ class FlowMockService extends BaseService {
     }
     deleteOne(id, force = false) {
         const flow = this.data.find((v) => v.id === id);
-        if (!flow?.deletedAt && !force) {
+        if (!(flow === null || flow === void 0 ? void 0 : flow.deletedAt) && !force) {
             flow.deletedAt = new Date().toISOString();
             return Promise.resolve(flow);
         }
@@ -34,19 +34,26 @@ class FlowMockService extends BaseService {
     }
     addOne(dto) {
         const id = (0, crypto_1.randomUUID)();
-        this.revisions.push({ ...dto, id, originalId: dto.id });
+        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.id }));
         return super.addOne(dto);
     }
-    async updateOne(id, dto) {
-        await super.deleteOne(id);
-        const flow = await this.addOne(dto);
-        return Promise.resolve(flow);
+    updateOne(id, dto) {
+        const _super = Object.create(null, {
+            deleteOne: { get: () => super.deleteOne }
+        });
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            yield _super.deleteOne.call(this, id);
+            const flow = yield this.addOne(dto);
+            return Promise.resolve(flow);
+        });
     }
-    async isDeploymentOnLatestDiagramVersion(depl) {
-        const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
-        const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
-        const revisions = await this.getDiagramRevisions(flowId);
-        return revisions[revisions.length - 1].id === diagramId;
+    isDeploymentOnLatestDiagramVersion(depl) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const flowId = typeof depl.flow === 'string' ? depl.flow : depl.flow.id;
+            const diagramId = typeof depl.diagram === 'string' ? depl.diagram : depl.diagram.id;
+            const revisions = yield this.getDiagramRevisions(flowId);
+            return revisions[revisions.length - 1].id === diagramId;
+        });
     }
     getDiagramRevisions(id) {
         return Promise.resolve(this.diagrams.filter((v) => v.flow === id));
@@ -54,13 +61,15 @@ class FlowMockService extends BaseService {
     getFlowWithDiagram(diagramId) {
         return Promise.resolve(this.data.find((v1) => v1.id === this.diagrams.find((v) => v.id === diagramId).flow));
     }
-    async getMany(params) {
-        const flows = this.getItems(params, false);
-        return {
-            docs: flows.docs.map((v) => ({ ...v, diagram: this.diagrams.find((v1) => v1.id === v.diagram) })),
-            total: 0,
-            limit: 0,
-        };
+    getMany(params) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const flows = this.getItems(params, false);
+            return {
+                docs: flows.docs.map((v) => (Object.assign(Object.assign({}, v), { diagram: this.diagrams.find((v1) => v1.id === v.diagram) }))),
+                total: 0,
+                limit: 0,
+            };
+        });
     }
     getRevisions(id) {
         const revisions = this.revisions.filter((revision) => revision.originalId === id);

package/dist/mock/secret.mock.service.js

@@ -17,7 +17,7 @@ class SecretMockService extends BaseService {
     }
     deleteOne(contentId, force = false) {
         const content = this.data.find((v) => v.id === contentId);
-        if (!content?.deletedAt && !force) {
+        if (!(content === null || content === void 0 ? void 0 : content.deletedAt) && !force) {
             content.deletedAt = new Date().toISOString();
             return Promise.resolve(content);
         }

package/dist/mock/task.mock.service.js

@@ -15,13 +15,15 @@ class TaskMockService extends BaseService {
     constructor(tasks) {
         super(tasks);
     }
-    async createTaskAttachedToAsset(dto) {
-        this.data.push(dto);
-        return Promise.resolve(dto);
+    createTaskAttachedToAsset(dto) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            this.data.push(dto);
+            return Promise.resolve(dto);
+        });
     }
     deleteOne(taskId, force = false) {
         const task = this.data.find((v) => v.id === taskId);
-        if (!task?.deletedAt && !force) {
+        if (!(task === null || task === void 0 ? void 0 : task.deletedAt) && !force) {
             task.deletedAt = new Date().toISOString();
             return Promise.resolve(task);
         }

package/dist/mock/timeseries.mock.service.js

@@ -13,12 +13,12 @@ BaseService = tslib_1.__decorate([
 ], BaseService);
 class TimeseriesMockService extends BaseService {
     constructor(timeseries, timeseriesValues) {
-        const data = timeseries.map((value, index) => ({ ...value, data: timeseriesValues[index] }));
+        const data = timeseries.map((value, index) => (Object.assign(Object.assign({}, value), { data: timeseriesValues[index] })));
         super(data);
     }
     deleteOne(tsmId, force = false) {
         const tsm = this.data.find((v) => v.id === tsmId);
-        if (!tsm?.deletedAt && !force) {
+        if (!(tsm === null || tsm === void 0 ? void 0 : tsm.deletedAt) && !force) {
             tsm.deletedAt = new Date().toISOString();
             return Promise.resolve(tsm);
         }
@@ -32,7 +32,7 @@ class TimeseriesMockService extends BaseService {
         const ts = this.data.find((v) => v.assetRef === assetId);
         const data = Object.entries(values).map(([timestamp, value]) => {
             if (value !== null && typeof value === 'object') {
-                return { timestamp, ...value };
+                return Object.assign({ timestamp }, value);
             }
             else {
                 return { timestamp, value };
@@ -56,16 +56,18 @@ class TimeseriesMockService extends BaseService {
         ts.data = ts.data ? [...ts.data, ...data] : data;
         return Promise.resolve(ts);
     }
-    async addValue(id, value) {
-        const ts = await this.getOne(id, {});
-        for (const [timestamp, v] of Object.entries(value)) {
-            if (v !== null && typeof v === 'object') {
-                ts.data.push({ timestamp, ...v });
+    addValue(id, value) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const ts = yield this.getOne(id, {});
+            for (const [timestamp, v] of Object.entries(value)) {
+                if (v !== null && typeof v === 'object') {
+                    ts.data.push(Object.assign({ timestamp }, v));
+                }
+                else {
+                    ts.data.push({ timestamp: parseInt(timestamp, 10), value: v });
+                }
             }
-            else {
-                ts.data.push({ timestamp: parseInt(timestamp, 10), value: v });
-            }
-        }
+        });
     }
     getManyByAsset(assetId, names) {
         const page = { docs: [], limit: 10, total: 0 };
@@ -80,24 +82,30 @@ class TimeseriesMockService extends BaseService {
         page.total = page.docs.length;
         return Promise.resolve(page);
     }
-    async getMostRecentValue(id, before) {
-        const ts = await this.getOne(id, {});
-        for (const datum of ts.data) {
-            if (datum.timestamp < before.valueOf()) {
-                return datum;
+    getMostRecentValue(id, before) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const ts = yield this.getOne(id, {});
+            for (const datum of ts.data) {
+                if (datum.timestamp < before.valueOf()) {
+                    return datum;
+                }
             }
-        }
+        });
     }
-    async getValues(id, from, limit, group) {
-        let timeSeriesValues = await this.getValuesOfPeriod(id, from, new Date().valueOf(), group);
-        if (limit) {
-            timeSeriesValues = timeSeriesValues.slice(0, limit);
-        }
-        return timeSeriesValues;
+    getValues(id, from, limit, group) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let timeSeriesValues = yield this.getValuesOfPeriod(id, from, new Date().valueOf(), group);
+            if (limit) {
+                timeSeriesValues = timeSeriesValues.slice(0, limit);
+            }
+            return timeSeriesValues;
+        });
     }
-    async getValuesOfPeriod(id, from, to, group) {
-        const ts = await this.getOne(id, {});
-        return ts.data.filter((v) => v.timestamp < to && v.timestamp > from);
+    getValuesOfPeriod(id, from, to, group) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const ts = yield this.getOne(id, {});
+            return ts.data.filter((v) => v.timestamp < to && v.timestamp > from);
+        });
     }
 }
 exports.TimeseriesMockService = TimeseriesMockService;

package/dist/mock/trash.mock.service.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrashMockService = void 0;
+const tslib_1 = require("tslib");
 const trash_service_1 = require("../trash.service");
 class TrashMockService extends trash_service_1.TrashService {
     constructor() {
@@ -19,12 +20,14 @@ class TrashMockService extends trash_service_1.TrashService {
         delete deleted['deletedAt'];
         return Promise.resolve(deleted);
     }
-    async emptyTrash(offset) {
-        const dateOffsSeconds = Math.round(new Date().getTime() / 1000) - offset;
-        const date = new Date(dateOffsSeconds * 1000);
-        const trashIds = this.data.filter((v) => new Date(v['deletedAt']) < date).map((v) => v.id);
-        this.data = this.data.filter((item) => !trashIds.includes(item.id));
-        return Promise.resolve({ acknowledged: true, deletedCount: trashIds.length });
+    emptyTrash(offset) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const dateOffsSeconds = Math.round(new Date().getTime() / 1000) - offset;
+            const date = new Date(dateOffsSeconds * 1000);
+            const trashIds = this.data.filter((v) => new Date(v['deletedAt']) < date).map((v) => v.id);
+            this.data = this.data.filter((item) => !trashIds.includes(item.id));
+            return Promise.resolve({ acknowledged: true, deletedCount: trashIds.length });
+        });
     }
     getTrash(params) {
         const page = this.getItems(params, true);

package/dist/timeseries.service.d.ts

@@ -16,7 +16,7 @@ export declare class TimeSeriesService extends BaseService {
     addAssetTimeSeriesValues(assetId: string, name: string, readPermissions: string[], readWritePermissions: string[], values: {
         [timestamp: string]: any;
     }): Promise<TimeSeries>;
-    getMostRecentValue(id: string, before: Date): Promise<TimeSeriesValue>;
+    getMostRecentValue(id: string, before?: Date): Promise<TimeSeriesValue>;
     getValues(id: string, from: number, limit?: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
     getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
     getManyByAsset(assetId: string, names?: string[]): Promise<Paginated<TimeSeries[]>>;

package/dist/user.service.js

@@ -8,15 +8,17 @@ class UserService {
         this.httpClient = httpClient;
         this.basePath = '/user';
     }
-    async getCurrentUserRoles() {
-        try {
-            const token = await this.httpClient.getAccessToken();
-            const decode = (0, jwt_decode_1.default)(token);
-            return decode.realm_access.roles;
-        }
-        catch (err) {
-            return null;
-        }
+    getCurrentUserRoles() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const token = yield this.httpClient.getAccessToken();
+                const decode = (0, jwt_decode_1.default)(token);
+                return decode.realm_access.roles;
+            }
+            catch (err) {
+                return null;
+            }
+        });
     }
     getUserSettings() {
         return this.httpClient.get(this.basePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "description": "Module for easy access to the HahnPRO API",
   "license": "MIT",
   "author": {
@@ -24,7 +24,7 @@
     "access": "public"
   },
   "dependencies": {
-    "axios": "~1.4.0",
+    "axios": "~1.5.0",
     "eventsource": "^2.0.2",
     "form-data": "^4.0.0",
     "jose": "^4.14.4",