@hahnpro/hpc-api 6.0.0 → 2024.4.0-0

package/src/lib/http.service.js

@@ -0,0 +1,179 @@
+import { stringify } from 'querystring';
+import axios from 'axios';
+import EventSource from 'eventsource';
+import { CompactSign, decodeJwt } from 'jose';
+import { Queue } from './Queue';
+import { TokenSet } from './token-set';
+export class HttpClient {
+    constructor(baseURL, authBaseURL, realm, clientId, clientSecret, tokenSubject) {
+        this.baseURL = baseURL;
+        this.authBaseURL = authBaseURL;
+        this.realm = realm;
+        this.clientId = clientId;
+        this.clientSecret = clientSecret;
+        this.tokenSubject = tokenSubject;
+        this.discoveredIssuers = new Map();
+        this.eventSourcesMap = new Map();
+        this.getQueueStats = () => this.requestQueue?.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);
+        this.put = (url, data, config) => this.request('PUT', url, config, data);
+        this.request = (method, url, config = {}, data) => {
+            return this.requestQueue.add(() => new Promise((resolve, reject) => {
+                const tokenP = config.token ? Promise.resolve(config.token) : this.getAccessToken();
+                tokenP
+                    .then((token) => {
+                    const headers = { Authorization: `Bearer ${token}`, ...config.headers };
+                    return this.axiosInstance.request({ ...config, headers, method, url, data });
+                })
+                    .then((response) => resolve(response.data))
+                    .catch(reject);
+            }));
+        };
+        this.getAccessToken = async (forceRefresh = false) => {
+            let accessToken;
+            if (forceRefresh || !this.tokenSet || this.tokenSet.isExpired()) {
+                if (this.tokenSet?.provided) {
+                    throw new Error('provided token is expired and cannot be refreshed, provide a new token.');
+                }
+                this.tokenSet = await this.requestAccessToken();
+                accessToken = this.tokenSet.accessToken;
+            }
+            else {
+                accessToken = this.tokenSet.accessToken;
+            }
+            if (this.tokenSubject) {
+                if (forceRefresh || !this.exchangedTokenSet || this.exchangedTokenSet.isExpired()) {
+                    this.exchangedTokenSet = await this.exchangeAccessToken(accessToken);
+                }
+                return this.exchangedTokenSet.accessToken;
+            }
+            else {
+                return accessToken;
+            }
+        };
+        this.axiosInstance = axios.create({ baseURL, timeout: 60000 });
+        this.authAxiosInstance = axios.create({ baseURL: authBaseURL || baseURL, timeout: 10000 });
+        this.requestQueue = new Queue({ concurrency: 1, timeout: 70000, throwOnTimeout: true });
+    }
+    async addEventSource(url, listener, errorListener, options = {}) {
+        const id = generateUUID();
+        const errListener = errorListener
+            ? errorListener
+            : (event) => {
+                throw new Error(JSON.stringify(event, null, 2));
+            };
+        const token = options.token ? options.token : await this.getAccessToken();
+        const es = new EventSource(`${this.baseURL}${url}`, {
+            headers: { authorization: 'Bearer ' + token },
+        });
+        es.addEventListener('message', listener);
+        es.addEventListener('error', errListener);
+        // the listeners have to be saved otherwise they cannot be removed
+        this.eventSourcesMap.set(id, { eventSource: es, listener, errListener });
+        return id;
+    }
+    destroyEventSource(id) {
+        if (!this.eventSourcesMap.has(id)) {
+            return;
+        }
+        const es = this.eventSourcesMap.get(id);
+        // close and unbind listeners so that the process quits cleanly
+        es.eventSource.close();
+        es.eventSource.removeEventListener('message', es.listener);
+        es.eventSource.removeEventListener('error', es.errListener);
+        this.eventSourcesMap.delete(id);
+    }
+    destroyAllEventSources() {
+        for (const key of this.eventSourcesMap.keys()) {
+            this.destroyEventSource(key);
+        }
+    }
+    validateIssuer(issuer) {
+        if (!issuer.issuer ||
+            !issuer.grant_types_supported?.includes('client_credentials') ||
+            !issuer.token_endpoint_auth_methods_supported?.includes('client_secret_jwt')) {
+            throw new Error('Issuer does not support client_secret_jwt');
+        }
+        return issuer;
+    }
+    async discoverIssuer(uri) {
+        if (this.discoveredIssuers.has(uri)) {
+            return this.discoveredIssuers.get(uri);
+        }
+        const wellKnownUri = `${uri}/.well-known/openid-configuration`;
+        const issuerResponse = await this.authAxiosInstance.get(wellKnownUri, {
+            responseType: 'json',
+            headers: { Accept: 'application/json' },
+        });
+        const validIssuer = this.validateIssuer(issuerResponse.data);
+        this.discoveredIssuers.set(uri, validIssuer);
+        return validIssuer;
+    }
+    async requestAccessToken(additionalOpts = {}) {
+        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: generateUUID(),
+            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 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',
+            ...additionalOpts,
+        };
+        const authResponse = await this.authAxiosInstance.post(issuer.token_endpoint, stringify(opts), {
+            headers: { Accept: 'application/json', 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        if (authResponse?.data?.access_token && authResponse.data.expires_in) {
+            return new TokenSet(authResponse.data.access_token, authResponse.data.expires_in);
+        }
+        else {
+            throw new Error('Invalid access token received');
+        }
+    }
+    async exchangeAccessToken(accessToken) {
+        if (!accessToken || !this.tokenSubject) {
+            throw new Error('Could not exchange access token');
+        }
+        const opts = {
+            grant_type: 'urn:ietf:params:oauth:grant-type:token-exchange',
+            subject_token: accessToken,
+            audience: this.clientId,
+            requested_token_type: 'urn:ietf:params:oauth:token-type:access_token',
+            requested_subject: this.tokenSubject,
+        };
+        return this.requestAccessToken(opts);
+    }
+    async provideExternalToken(token) {
+        const issuer = await this.discoverIssuer(`${this.authBaseURL}/realms/${this.realm}`);
+        const { iss: providedIssuer, exp } = decodeJwt(token);
+        if (issuer.issuer !== providedIssuer) {
+            throw new Error(`Provided token is not issued by currently configured issuer. Provided token issued by ${providedIssuer}, but ${issuer.issuer} is configured.`);
+        }
+        this.tokenSet = new TokenSet(token, exp - Date.now() / 1000, true);
+    }
+}
+function generateUUID() {
+    if (typeof globalThis.crypto?.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    throw new Error('randomUUID() not available in this environment. Please upgrade to Node 20+ or a modern browser.');
+}

package/src/lib/label.interface.js

@@ -0,0 +1 @@
+export {};

package/{dist → src/lib}/label.service.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LabelService = void 0;
-const data_service_1 = require("./data.service");
-class LabelService extends data_service_1.DataService {
+import { DataService } from './data.service';
+export class LabelService extends DataService {
     constructor(httpClient) {
         super(httpClient, '/labels');
     }
@@ -16,4 +13,3 @@ class LabelService extends data_service_1.DataService {
         return this.httpClient.get(`${this.basePath}/count`, options);
     }
 }
-exports.LabelService = LabelService;

package/src/lib/mock/api-base.mock.js

@@ -0,0 +1,7 @@
+import { APIBase } from '../api-base';
+export class APIBaseMock extends APIBase {
+    constructor(data = []) {
+        super(null, null);
+        this.data = data;
+    }
+}

package/src/lib/mock/api.mock.js

@@ -0,0 +1,199 @@
+import { randomUUID } from 'crypto';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { AssetMockService } from './asset.mock.service';
+import { AssetTypesMockService } from './assetTypes.mock.service';
+import { ContentMockService } from './content.mock.service';
+import { EndpointMockService } from './endpoint.mock.service';
+import { EventsMockService } from './events.mock.service';
+import { FlowDeploymentMockService } from './flow-deployment.mock.service';
+import { FlowFunctionsMockService } from './flow-functions.mock.service';
+import { FlowModulesMockService } from './flow-modules.mock.service';
+import { FlowMockService } from './flow.mock.service';
+import { LabelMockService } from './label.mock.service';
+import { NotificationMockService } from './notification.mock.service';
+import { SecretMockService } from './secret.mock.service';
+import { TaskMockService } from './task.mock.service';
+import { TimeseriesMockService } from './timeseries.mock.service';
+import { UserMockService } from './user.mock.service';
+import { VaultMockService } from './vault.mock.service';
+export class MockAPI {
+    constructor(initData) {
+        this.httpClient = null;
+        this.proxy = null;
+        const { assets = [], assetRevisions = [], contents = [], endpoints = [], secrets = [], timeSeries = [], tasks = [], events = [], users, flows = [], flowRevisions = [], deployments = [], functions = [], functionRevisions = [], modules = [], diagrams = [], labels = [], vault = [], notifications = [], } = initData;
+        // convert init data to normal data that the services usually use
+        const assetTypes = assets
+            .map((v) => v.type)
+            .map((v) => {
+            return typeof v === 'string'
+                ? v
+                : {
+                    ...v,
+                    readPermissions: v.readPermissions || [],
+                    readWritePermissions: v.readWritePermissions || [],
+                    typeSchema: v.typeSchema ?? {},
+                    uiSchema: v.uiSchema ?? {},
+                };
+        });
+        const assets1 = assets.map((v, index) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            type: assetTypes[index],
+        }));
+        const assetRevisions1 = assetRevisions.map((v, index) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            type: assetTypes[index],
+        }));
+        const contents1 = contents.map((v) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            size: v.size ?? 0,
+            fileId: v.fileId ?? '',
+            mimetype: v.mimetype ?? '',
+        }));
+        const contentData = contents.map((v) => (v.data ? v.data : readFileSync(join(v.filePath, v.filename))));
+        const secrets1 = secrets.map((v) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+        }));
+        const timeSeries1 = timeSeries.map((v) => ({
+            ...v,
+            description: v.description ?? '',
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            maxBucketTimeRange: v.maxBucketTimeRange ?? 0,
+            maxDate: v.maxDate,
+            minDate: v.minDate,
+            autoDelData: v.autoDelData ?? new Date(),
+            autoDelBucket: v.autoDelBucket ?? new Date(),
+        }));
+        const timeSeriesValues = timeSeries.map((v) => v.values);
+        const endpoint1 = endpoints.map((v) => ({
+            ...v,
+            status: v.status,
+            config: v.config,
+            notificationCheckInterval: v.notificationCheckInterval,
+            notificationPauseInterval: v.notificationPauseInterval,
+            nbOfNotificationsBetweenPauseInterval: v.nbOfNotificationsBetweenPauseInterval,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+        }));
+        // TODO: ...
+        const tasks1 = tasks.map((v) => ({
+            ...v,
+            id: v.id,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            subTasks: v.subTasks ?? [],
+        }));
+        const events1 = events.map((v) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            cause: v.cause,
+            level: v.level,
+        }));
+        const diagrams1 = diagrams.map((v) => ({
+            ...v,
+            json: v.json ?? '',
+            author: 'nobody',
+        }));
+        const flows1 = flows.map((v) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            diagram: diagrams.find((v1) => v1.flow === v.id).id,
+            name: `flow-${v.id}`,
+            deployments: v.deployments ?? [],
+        }));
+        const flowRevisions1 = flowRevisions.map((v) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            diagram: diagrams.find((v1) => v1.flow === v.originalId).id,
+            name: `flow-${v.id}`,
+            deployments: v.deployments ?? [],
+        }));
+        const deployments1 = deployments.map((v) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            diagram: v.diagram ?? '',
+            artifact: v.artifact ?? null,
+            flowModel: v.flowModel ?? { connections: [], elements: [] },
+            desiredStatus: 'running',
+            actualStatus: 'generating queued',
+            target: 'executor',
+            name: `deployment-${v.id}`,
+        }));
+        const functions1 = functions.map((v) => ({
+            ...v,
+            category: 'task',
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            author: 'nobody',
+        }));
+        const functionRevisions1 = functionRevisions.map((v) => ({
+            ...v,
+            category: 'task',
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+            author: 'nobody',
+        }));
+        const modules1 = modules.map((v, index) => ({
+            ...v,
+            artifacts: modules[index].artifacts.map((art) => ({
+                ...art,
+                version: '0.0.0',
+                id: randomUUID(),
+                mimetype: '',
+                size: 0,
+                createdAt: '' + Date.now(),
+            })) ?? [],
+            author: 'nobody',
+            functions: v.functions ?? [],
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+        }));
+        const labels1 = labels.map((v) => ({
+            ...v,
+            color: v.color ?? '',
+            description: v.description ?? '',
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+        }));
+        const vaultSecrets1 = vault.map((v) => ({
+            ...v,
+            readPermissions: v.readPermissions ?? [],
+            readWritePermissions: v.readWritePermissions ?? [],
+        }));
+        const notifications1 = notifications.map((v) => ({
+            ...v,
+            link: v.link ?? '',
+            description: v.description ?? '',
+            read: v.read ?? false,
+        }));
+        this.assets = new AssetMockService(this, assets1, assetRevisions1);
+        this.assetTypes = new AssetTypesMockService(assetTypes, []);
+        this.contents = new ContentMockService(contents1, contentData);
+        this.endpoints = new EndpointMockService(endpoint1);
+        this.secrets = new SecretMockService(secrets1);
+        this.timeSeries = new TimeseriesMockService(timeSeries1, timeSeriesValues);
+        this.tasks = new TaskMockService(tasks1);
+        this.events = new EventsMockService(events1);
+        this.users = new UserMockService(users);
+        this.flows = new FlowMockService(flows1, diagrams1, flowRevisions1);
+        this.flowDeployments = new FlowDeploymentMockService(deployments1, this);
+        this.flowFunctions = new FlowFunctionsMockService(functions1, functionRevisions1);
+        this.flowModules = new FlowModulesMockService(modules1);
+        this.labels = new LabelMockService(labels1);
+        this.vault = new VaultMockService(vaultSecrets1);
+        this.notifications = new NotificationMockService(notifications1);
+    }
+}

package/{dist → src/lib}/mock/asset.mock.service.js

@@ -1,17 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetMockService = void 0;
-const tslib_1 = require("tslib");
-const ts_mixer_1 = require("ts-mixer");
-const api_base_mock_1 = require("./api-base.mock");
-const data_mock_service_1 = require("./data.mock.service");
-const trash_mock_service_1 = require("./trash.mock.service");
-let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+import { __decorate } from "tslib";
+import { mix } from 'ts-mixer';
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+let BaseService = class BaseService extends APIBaseMock {
 };
-BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
 ], BaseService);
-class AssetMockService extends BaseService {
+export class AssetMockService extends BaseService {
     constructor(api, assets, revisions) {
         super(assets);
         this.api = api;
@@ -27,12 +24,13 @@ class AssetMockService extends BaseService {
         return page;
     }
     addOne(dto) {
-        this.revisions.push(Object.assign(Object.assign({}, dto), { originalId: dto.id }));
+        this.revisions.push({ ...dto, originalId: dto.id });
         return super.addOne(dto);
     }
     deleteOne(assetId, force = false) {
         const asset = this.data.find((v) => v.id === assetId);
-        if (!(asset === null || asset === void 0 ? void 0 : asset.deletedAt) && !force) {
+        if (!asset?.deletedAt && !force) {
+            // put asset in paper bin by setting deletedAt prop
             asset.deletedAt = new Date().toISOString();
             return Promise.resolve(asset);
         }
@@ -48,42 +46,34 @@ class AssetMockService extends BaseService {
         const page = this.getAssets(params, false);
         return Promise.resolve(page);
     }
-    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 updateOne(assetId, dto) {
+        await super.deleteOne(assetId);
+        const asset = await this.addOne(dto);
+        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 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);
     }
-    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 };
-        });
+    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 };
     }
     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) => {
-            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 : {} }));
-        }, {}));
+        return Promise.resolve(ids.reduce((acc, id) => ({
+            ...acc,
+            [id]: eventCausesAssets.find((v) => v.name.includes(id))?.data ?? {},
+        }), {}));
     }
     updateEventCausesAsset(id, dto) {
+        // simplified id and data
         const asset = this.data.find((v) => v.id === id);
         const eventCausesAsset = this.data.find((v) => v.name === 'hpc-event-causes-' + asset.id);
         if (eventCausesAsset) {
@@ -119,4 +109,3 @@ class AssetMockService extends BaseService {
         return Promise.resolve(revisionId);
     }
 }
-exports.AssetMockService = AssetMockService;

package/{dist → src/lib}/mock/assetTypes.mock.service.js

@@ -1,18 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssetTypesMockService = void 0;
-const tslib_1 = require("tslib");
-const crypto_1 = require("crypto");
-const ts_mixer_1 = require("ts-mixer");
-const api_base_mock_1 = require("./api-base.mock");
-const data_mock_service_1 = require("./data.mock.service");
-const trash_mock_service_1 = require("./trash.mock.service");
-let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+import { __decorate } from "tslib";
+import { randomUUID } from 'crypto';
+import { mix } from 'ts-mixer';
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+let BaseService = class BaseService extends APIBaseMock {
 };
-BaseService = tslib_1.__decorate([
-    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
 ], BaseService);
-class AssetTypesMockService extends BaseService {
+export class AssetTypesMockService extends BaseService {
     constructor(assetTypes, revisions) {
         const defaultTyp = {
             name: 'defaultType',
@@ -21,7 +18,7 @@ class AssetTypesMockService extends BaseService {
             typeSchema: { type: 'object' },
             uiSchema: {},
         };
-        const types = assetTypes.map((type) => (typeof type === 'string' ? Object.assign({ id: type }, defaultTyp) : type));
+        const types = assetTypes.map((type) => (typeof type === 'string' ? { id: type, ...defaultTyp } : type));
         super(types);
         this.revisions = revisions;
     }
@@ -30,13 +27,14 @@ class AssetTypesMockService extends BaseService {
         return Promise.resolve(page);
     }
     addOne(dto) {
-        const id = (0, crypto_1.randomUUID)();
-        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.id }));
+        const id = randomUUID();
+        this.revisions.push({ ...dto, id, originalId: dto.id });
         return super.addOne(dto);
     }
     deleteOne(id, force = false) {
         const assettype = this.data.find((v) => v.id === id);
-        if (!(assettype === null || assettype === void 0 ? void 0 : assettype.deletedAt) && !force) {
+        if (!assettype?.deletedAt && !force) {
+            // put asset in paper bin by setting deletedAt prop
             assettype.deletedAt = new Date().toISOString();
             return Promise.resolve(assettype);
         }
@@ -48,15 +46,10 @@ class AssetTypesMockService extends BaseService {
         });
         return super.deleteOne(id);
     }
-    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);
-        });
+    async updateOne(id, dto) {
+        await super.deleteOne(id);
+        const assetType = await this.addOne(dto);
+        return Promise.resolve(assetType);
     }
     getRevisions(id) {
         const revisions = this.revisions.filter((revision) => revision.originalId === id);
@@ -77,4 +70,3 @@ class AssetTypesMockService extends BaseService {
         return Promise.resolve(revisionId);
     }
 }
-exports.AssetTypesMockService = AssetTypesMockService;