@hahnpro/hpc-api 2025.2.0 → 2025.2.1

package/src/lib/mock/assetTypes.mock.service.js

@@ -1,62 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "AssetTypesMockService", {
-    enumerable: true,
-    get: function() {
-        return AssetTypesMockService;
-    }
-});
-const _ts_decorate = require("@swc/helpers/_/_ts_decorate");
-const _crypto = require("crypto");
-const _tsmixer = require("ts-mixer");
-const _apibasemock = require("./api-base.mock");
-const _datamockservice = require("./data.mock.service");
-const _trashmockservice = require("./trash.mock.service");
-let BaseService = class BaseService extends _apibasemock.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 = _ts_decorate._([
-    (0, _tsmixer.mix)(_datamockservice.DataMockService, _trashmockservice.TrashMockService)
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
 ], BaseService);
-let AssetTypesMockService = class AssetTypesMockService extends BaseService {
-    constructor(assetTypes, revisions){
+export class AssetTypesMockService extends BaseService {
+    constructor(assetTypes, revisions) {
         const defaultTyp = {
             name: 'defaultType',
             readPermissions: [],
             readWritePermissions: [],
-            typeSchema: {
-                type: 'object'
-            },
-            uiSchema: {}
+            typeSchema: { type: 'object' },
+            uiSchema: {},
         };
-        const types = assetTypes.map((type)=>typeof type === 'string' ? {
-                id: type,
-                ...defaultTyp
-            } : type);
-        super(types), this.revisions = revisions;
+        const types = assetTypes.map((type) => (typeof type === 'string' ? { id: type, ...defaultTyp } : type));
+        super(types);
+        this.revisions = revisions;
     }
     getMany(params) {
         const page = this.getItems(params, false);
         return Promise.resolve(page);
     }
     addOne(dto) {
-        const id = (0, _crypto.randomUUID)();
-        this.revisions.push({
-            ...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);
+        const assettype = this.data.find((v) => v.id === id);
         if (!assettype?.deletedAt && !force) {
             // put asset in paper bin by setting deletedAt prop
             assettype.deletedAt = new Date().toISOString();
             return Promise.resolve(assettype);
         }
-        this.revisions.filter((revision)=>revision.originalId === id).forEach((revision)=>{
+        this.revisions
+            .filter((revision) => revision.originalId === id)
+            .forEach((revision) => {
             const index = this.revisions.indexOf(revision);
             this.revisions.splice(index, 1);
         });
@@ -68,23 +52,21 @@ let AssetTypesMockService = class AssetTypesMockService extends BaseService {
         return Promise.resolve(assetType);
     }
     getRevisions(id) {
-        const revisions = this.revisions.filter((revision)=>revision.originalId === id);
+        const revisions = this.revisions.filter((revision) => revision.originalId === id);
         const page = {
             docs: revisions,
             limit: Number.MAX_SAFE_INTEGER,
-            total: revisions.length
+            total: revisions.length,
         };
         return Promise.resolve(page);
     }
     rollback(id, revisionId) {
-        const assetType = this.revisions.find((revision)=>revision.id === revisionId);
+        const assetType = this.revisions.find((revision) => revision.id === revisionId);
         return Promise.resolve(assetType);
     }
     deleteRevision(assetId, revisionId) {
-        const index = this.revisions.findIndex((revision)=>revision.id === revisionId);
+        const index = this.revisions.findIndex((revision) => revision.id === revisionId);
         this.revisions.splice(index, 1);
         return Promise.resolve(revisionId);
     }
-};
-
-//# sourceMappingURL=assetTypes.mock.service.js.map
+}

package/src/lib/mock/content.mock.service.js

@@ -1,75 +1,69 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "ContentMockService", {
-    enumerable: true,
-    get: function() {
-        return ContentMockService;
-    }
-});
-const _ts_decorate = require("@swc/helpers/_/_ts_decorate");
-const _stream = require("stream");
-const _tsmixer = require("ts-mixer");
-const _contentinterface = require("../content.interface");
-const _apibasemock = require("./api-base.mock");
-const _datamockservice = require("./data.mock.service");
-const _trashmockservice = require("./trash.mock.service");
-let BaseService = class BaseService extends _apibasemock.APIBaseMock {
+import { __decorate } from "tslib";
+import { Readable } from 'stream';
+import { mix } from 'ts-mixer';
+import { ReturnType } from '../content.interface';
+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 = _ts_decorate._([
-    (0, _tsmixer.mix)(_datamockservice.DataMockService, _trashmockservice.TrashMockService)
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
 ], BaseService);
-let ContentMockService = class ContentMockService extends BaseService {
-    constructor(contents, contentData){
-        super(contents), this.contentData = new Map();
-        for(let i = 0; i < contents.length; i++){
+export class ContentMockService extends BaseService {
+    constructor(contents, contentData) {
+        super(contents);
+        this.contentData = new Map();
+        for (let i = 0; i < contents.length; i++) {
             this.contentData.set(contents[i].id, contentData[i]);
         }
     }
     download(id, second) {
         let returnType;
         if (typeof second === 'boolean' || second == null) {
-            returnType = second ? _contentinterface.ReturnType.ARRAYBUFFER : _contentinterface.ReturnType.BLOB;
-        } else {
+            returnType = second ? ReturnType.ARRAYBUFFER : ReturnType.BLOB;
+        }
+        else {
             returnType = second;
         }
         const content = this.contentData.get(id);
-        switch(returnType){
-            case _contentinterface.ReturnType.TEXT:
+        switch (returnType) {
+            case ReturnType.TEXT:
                 if (typeof content === 'string') {
                     return Promise.resolve(content);
-                } else {
+                }
+                else {
                     return Promise.resolve(JSON.stringify(content));
                 }
-            case _contentinterface.ReturnType.JSON:
+            case ReturnType.JSON:
                 if (typeof content !== 'string') {
                     return Promise.resolve(content);
-                } else {
+                }
+                else {
                     return Promise.resolve(JSON.parse(content));
                 }
-            case _contentinterface.ReturnType.NODEBUFFER:
+            case ReturnType.NODEBUFFER:
                 return Promise.resolve(Buffer.from(this.contentData.get(id)));
-            case _contentinterface.ReturnType.BLOB:
+            case ReturnType.BLOB:
                 if (global.Blob) {
-                    return Promise.resolve(new Blob([
-                        Buffer.from(this.contentData.get(id)).buffer
-                    ]));
-                } else {
+                    return Promise.resolve(new Blob([Buffer.from(this.contentData.get(id)).buffer]));
+                }
+                else {
                     if (typeof content === 'string') {
                         return Promise.resolve(content);
-                    } else {
+                    }
+                    else {
                         return Promise.resolve(JSON.stringify(content));
                     }
                 }
-            case _contentinterface.ReturnType.ARRAYBUFFER:
+            case ReturnType.ARRAYBUFFER:
                 return Promise.resolve(Buffer.from(this.contentData.get(id)).buffer);
-            case _contentinterface.ReturnType.NODESTREAM:
-                return Promise.resolve(_stream.Readable.from(this.contentData.get(id)));
+            case ReturnType.NODESTREAM:
+                return Promise.resolve(Readable.from(this.contentData.get(id)));
         }
     }
     deleteOne(contentId, force = false) {
-        const content = this.data.find((v)=>v.id === contentId);
+        const content = this.data.find((v) => v.id === contentId);
         if (!content?.deletedAt && !force) {
             // put content in paper bin by setting deletedAt prop
             content.deletedAt = new Date().toISOString();
@@ -84,6 +78,4 @@ let ContentMockService = class ContentMockService extends BaseService {
     upload(form) {
         return Promise.resolve(undefined);
     }
-};
-
-//# sourceMappingURL=content.mock.service.js.map
+}

package/src/lib/mock/data.mock.service.js

@@ -1,21 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "DataMockService", {
-    enumerable: true,
-    get: function() {
-        return DataMockService;
-    }
-});
-const _datainterface = require("../data.interface");
-const _dataservice = require("../data.service");
-let DataMockService = class DataMockService extends _dataservice.DataService {
-    constructor(){
-        super(null, null), this.data = [];
+import { instanceOfTimePeriod } from '../data.interface';
+import { DataService } from '../data.service';
+export class DataMockService extends DataService {
+    constructor() {
+        super(null, null);
+        this.data = [];
     }
     async addMany(dto) {
-        const map = dto.map((v)=>this.addOne(v));
+        const map = dto.map((v) => this.addOne(v));
         return Promise.all(map);
     }
     addOne(dto) {
@@ -23,7 +14,7 @@ let DataMockService = class DataMockService extends _dataservice.DataService {
         return Promise.resolve(dto);
     }
     deleteOne(id) {
-        const index = this.data.findIndex((v)=>v.id === id);
+        const index = this.data.findIndex((v) => v.id === id);
         const obj = this.data[index];
         this.data.splice(index, 1);
         return Promise.resolve(obj);
@@ -36,42 +27,48 @@ let DataMockService = class DataMockService extends _dataservice.DataService {
         const page = {
             docs: data,
             limit: params?.limit ?? Number.MAX_SAFE_INTEGER,
-            total: data.length
+            total: data.length,
         };
         return Promise.resolve(page);
     }
     /**
-   * Filters the elements by the passed properties. The object with these properties has to be of the form:
-   * {
-   *   propertyName: string | string[] | { from: Date, to: Date },
-   *   ...
-   * }.
-   * @param filter The Object with the properties to filter by.
-   * @param params Other request parameters.
-   */ async getManyFiltered(filter, params = {}) {
+     * Filters the elements by the passed properties. The object with these properties has to be of the form:
+     * {
+     *   propertyName: string | string[] | { from: Date, to: Date },
+     *   ...
+     * }.
+     * @param filter The Object with the properties to filter by.
+     * @param params Other request parameters.
+     */
+    async getManyFiltered(filter, params = {}) {
         const paginated = await this.getMany(params);
-        const newData = paginated.docs.filter((doc)=>Object.entries(filter).every(([filterKey, filterValue])=>{
-                const docValue = doc[filterKey];
-                if (!docValue) {
-                    return false;
-                }
-                return typeof docValue === 'object' && (filterValue === docValue.name || filterValue === docValue.id) || // data object
-                typeof filterValue === 'object' && (0, _datainterface.instanceOfTimePeriod)(filterValue) && new Date(docValue) >= filterValue.from && new Date(docValue) <= filterValue.to || // TimePeriod
-                docValue instanceof Date && filterValue === docValue.toISOString() || // Date
-                Array.isArray(filterValue) && Array.isArray(docValue) && filterValue.some((fv)=>docValue.includes(fv)) || // string[]
-                Array.isArray(filterValue) && filterValue.includes(docValue) || Array.isArray(docValue) && docValue.includes(filterValue) || docValue === filterValue // string
-                ;
-            }));
+        const newData = paginated.docs.filter((doc) => Object.entries(filter).every(([filterKey, filterValue]) => {
+            const docValue = doc[filterKey];
+            if (!docValue) {
+                return false;
+            }
+            return ((typeof docValue === 'object' && (filterValue === docValue.name || filterValue === docValue.id)) || // data object
+                (typeof filterValue === 'object' &&
+                    instanceOfTimePeriod(filterValue) &&
+                    new Date(docValue) >= filterValue.from &&
+                    new Date(docValue) <= filterValue.to) || // TimePeriod
+                (docValue instanceof Date && filterValue === docValue.toISOString()) || // Date
+                (Array.isArray(filterValue) && Array.isArray(docValue) && filterValue.some((fv) => docValue.includes(fv))) || // string[]
+                (Array.isArray(filterValue) && filterValue.includes(docValue)) ||
+                (Array.isArray(docValue) && docValue.includes(filterValue)) ||
+                docValue === filterValue // string
+            );
+        }));
         const page = {
             docs: newData,
             limit: paginated.limit ?? Number.MAX_SAFE_INTEGER,
-            total: newData.length
+            total: newData.length,
         };
         return Promise.resolve(page);
     }
     getOne(id, options = {}) {
         const idKey = options.idKey || 'id';
-        const t = this.data.find((v)=>v[idKey] === id);
+        const t = this.data.find((v) => v[idKey] === id);
         return Promise.resolve(t);
     }
     async updateOne(id, dto) {
@@ -82,14 +79,10 @@ let DataMockService = class DataMockService extends _dataservice.DataService {
     sortData(data, sort) {
         const descending = sort.startsWith('-');
         const sortString = descending ? sort.substring(1) : sort;
-        const compareFn = (a, b)=>{
+        const compareFn = (a, b) => {
             let aValue = a[sortString];
             let bValue = b[sortString];
-            if ([
-                'updatedAt',
-                'createdAt',
-                'deletedAt'
-            ].includes(sortString)) {
+            if (['updatedAt', 'createdAt', 'deletedAt'].includes(sortString)) {
                 aValue = new Date(a[sortString]).valueOf();
                 bValue = new Date(b[sortString]).valueOf();
             }
@@ -97,6 +90,4 @@ let DataMockService = class DataMockService extends _dataservice.DataService {
         };
         data.sort(compareFn);
     }
-};
-
-//# sourceMappingURL=data.mock.service.js.map
+}

package/src/lib/mock/endpoint.mock.service.js

@@ -1,16 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "EndpointMockService", {
-    enumerable: true,
-    get: function() {
-        return EndpointMockService;
-    }
-});
-const _datamockservice = require("./data.mock.service");
-let EndpointMockService = class EndpointMockService extends _datamockservice.DataMockService {
-    constructor(endpoints){
+import { DataMockService } from './data.mock.service';
+export class EndpointMockService extends DataMockService {
+    constructor(endpoints) {
         super();
         this.data = endpoints;
     }
@@ -24,9 +14,7 @@ let EndpointMockService = class EndpointMockService extends _datamockservice.Dat
             group: 'test',
             data: 'OK',
             createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString()
+            updatedAt: new Date().toISOString(),
         });
     }
-};
-
-//# sourceMappingURL=endpoint.mock.service.js.map
+}

package/src/lib/mock/events.mock.service.js

@@ -1,22 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "EventsMockService", {
-    enumerable: true,
-    get: function() {
-        return EventsMockService;
-    }
-});
-const _datamockservice = require("./data.mock.service");
-let EventsMockService = class EventsMockService extends _datamockservice.DataMockService {
-    constructor(events){
+import { DataMockService } from './data.mock.service';
+export class EventsMockService extends DataMockService {
+    constructor(events) {
         super();
         this.data = events;
     }
     getLastEventByAssetAndGroup(assetId, group) {
         return Promise.resolve(this.data[this.data.length - 1]);
     }
-};
-
-//# sourceMappingURL=events.mock.service.js.map
+}

package/src/lib/mock/flow-deployment.mock.service.js

@@ -1,42 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "FlowDeploymentMockService", {
-    enumerable: true,
-    get: function() {
-        return FlowDeploymentMockService;
-    }
-});
-const _ts_decorate = require("@swc/helpers/_/_ts_decorate");
-const _crypto = require("crypto");
-const _tsmixer = require("ts-mixer");
-const _apibasemock = require("./api-base.mock");
-const _datamockservice = require("./data.mock.service");
-const _trashmockservice = require("./trash.mock.service");
-let BaseService = class BaseService extends _apibasemock.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 = _ts_decorate._([
-    (0, _tsmixer.mix)(_datamockservice.DataMockService, _trashmockservice.TrashMockService)
+BaseService = __decorate([
+    mix(DataMockService, TrashMockService)
 ], BaseService);
-let FlowDeploymentMockService = class FlowDeploymentMockService extends BaseService {
-    constructor(deployments, api){
-        super(deployments), this.api = api;
+export class FlowDeploymentMockService extends BaseService {
+    constructor(deployments, api) {
+        super(deployments);
+        this.api = api;
     }
     subscribeToStatus(id, listener, errorListener) {
-        listener(new MessageEvent('message', {
-            data: 'running'
-        }));
-        return Promise.resolve((0, _crypto.randomUUID)());
+        listener(new MessageEvent('message', { data: 'running' }));
+        return Promise.resolve(randomUUID());
     }
     subscribeToLogs(id, listener, errorListener) {
-        listener(new MessageEvent('message', {
-            data: 'foo'
-        }));
-        return Promise.resolve((0, _crypto.randomUUID)());
+        listener(new MessageEvent('message', { data: 'foo' }));
+        return Promise.resolve(randomUUID());
     }
     async waitForRunningStatus(id) {
-        const flowDeployment = this.data.find((v)=>v.id === id);
+        const flowDeployment = this.data.find((v) => v.id === id);
         flowDeployment.actualStatus = 'running';
     }
     async updateStatus(id, desiredStatus) {
@@ -61,35 +48,17 @@ let FlowDeploymentMockService = class FlowDeploymentMockService extends BaseServ
                 ctime: 16770,
                 elapsed: 172850950,
                 timestamp: 1648199692625,
-                deploymentId: id
-            }
+                deploymentId: id,
+            },
         });
     }
     getDeploymentMetrics(id, range, interval) {
         return Promise.resolve({
-            metrics: [
-                {
-                    timestamp: Date.now(),
-                    cpu: 0,
-                    memory: Math.random() * 1000000
-                }
-            ],
+            metrics: [{ timestamp: Date.now(), cpu: 0, memory: Math.random() * 1000000 }],
             stats: {
-                cpu: {
-                    count: 123,
-                    avg: 0,
-                    max: 0,
-                    min: 0,
-                    sum: 0
-                },
-                memory: {
-                    count: 123,
-                    avg: 0,
-                    max: 0,
-                    min: 0,
-                    sum: 0
-                }
-            }
+                cpu: { count: 123, avg: 0, max: 0, min: 0, sum: 0 },
+                memory: { count: 123, avg: 0, max: 0, min: 0, sum: 0 },
+            },
         });
     }
     async getDeploymentLogs(id) {
@@ -105,59 +74,45 @@ let FlowDeploymentMockService = class FlowDeploymentMockService extends BaseServ
                 datacontenttype: 'text/plain',
                 elementId: 'none',
                 time: '2022-03-23T09:14:03.129Z',
-                flowId: depl.flow
-            }
+                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.randomUUID)();
+        const id = randomUUID();
         const newDepl = {
             actualStatus: 'generating queued',
             artifact: undefined,
             desiredStatus: 'running',
             diagram: dto.diagramId,
             flow: flow.id,
-            flowModel: {
-                elements: [],
-                connections: [],
-                properties: dto.properties
-            },
+            flowModel: { elements: [], connections: [], properties: dto.properties },
             id,
             name: dto.name,
             readPermissions: [],
             readWritePermissions: [],
             target: 'executor',
-            refs
+            refs,
         };
-        await this.api.flows.updateOne(flow.id, {
-            ...flow,
-            deployments: [
-                ...flow.deployments,
-                id
-            ]
-        });
+        await this.api.flows.updateOne(flow.id, { ...flow, deployments: [...flow.deployments, id] });
         return super.addOne(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);
+        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);
     }
     async getReferences(properties) {
         // super simplified version of real resolver
-        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'
-            };
+        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' };
         }));
     }
-};
-
-//# sourceMappingURL=flow-deployment.mock.service.js.map
+}