@hahnpro/hpc-api 2.0.0 → 2.2.0

package/dist/mock/api.mock.d.ts

@@ -1,5 +1,5 @@
 import { API } from '../api';
-import { Asset, AssetType } from '../asset.interface';
+import { Asset, AssetRevision, AssetType } from '../asset.interface';
 import { Content } from '../content.interface';
 import { Secret } from '../secret.interface';
 import { TimeSeries, TimeSeriesValue } from '../timeseries.interface';
@@ -15,6 +15,15 @@ import { Task } from '../task.interface';
 import { TimeseriesMockService } from './timeseries.mock.service';
 import { TaskMockService } from './task.mock.service';
 import { UserMockService } from './user.mock.service';
+import { FlowDeploymentService } from '../flow-deployment.service';
+import { FlowFunctionService } from '../flow-function.service';
+import { FlowModuleService } from '../flow-module.service';
+import { FlowService } from '../flow.service';
+import { FlowDiagram, FlowDto } from '../flow.interface';
+import { FlowDeployment } from '../flow-deployment.interface';
+import { FlowFunctionDto } from '../flow-function.interface';
+import { FlowModule } from '../flow-module.interface';
+import { Artifact } from '../storage.interface';
 export declare class MockAPI implements API {
     httpClient: any;
     assets: AssetMockService;
@@ -22,6 +31,10 @@ export declare class MockAPI implements API {
     contents: ContentMockService;
     endpoints: EndpointMockService;
     events: EventsMockService;
+    flows: FlowService;
+    flowDeployments: FlowDeploymentService;
+    flowFunctions: FlowFunctionService;
+    flowModules: FlowModuleService;
     proxy: any;
     secrets: SecretMockService;
     tasks: TaskMockService;
@@ -38,6 +51,7 @@ export declare class MockAPI implements API {
     userManager: UserMockService;
     constructor(initData: {
         assets?: AssetInit[];
+        revisions?: AssetRevisionInit[];
         contents?: ContentInit[];
         endpoints?: EndpointInit[];
         secrets?: SecretInit[];
@@ -45,6 +59,11 @@ export declare class MockAPI implements API {
         tasks?: TaskInit[];
         events?: EventInit[];
         users?: UserInit;
+        flows?: FlowInit[];
+        deployments?: FlowDeploymentInit[];
+        functions?: FlowFunctionInit[];
+        modules?: FlowModuleInit[];
+        diagrams?: FlowDiagramInit[];
     });
 }
 export declare type Identity<T> = {
@@ -55,6 +74,7 @@ export declare type Replace<T, K extends keyof T, TReplace> = Identity<Pick<T, E
     [P in K]: TReplace;
 }>;
 export declare type AssetInit = Replace<AtLeast<Asset, 'id' | 'name' | 'type'>, 'type', AssetTypeInit | string>;
+export declare type AssetRevisionInit = Replace<AtLeast<AssetRevision, 'id' | 'name' | 'type'>, 'type', AssetTypeInit | string>;
 export declare type AssetTypeInit = AtLeast<AssetType, 'id' | 'name'>;
 export declare type ContentInit = Identity<AtLeast<Content, 'id' | 'filename'> & {
     filePath?: string;
@@ -67,6 +87,16 @@ export declare type TimeSeriesInit = Identity<AtLeast<TimeSeries, 'id' | 'name'>
 }>;
 export declare type TaskInit = AtLeast<Task, 'name' | 'assignedTo'>;
 export declare type EventInit = AtLeast<Event, 'name'>;
+export declare type FlowInit = AtLeast<FlowDto, 'id'>;
+export declare type FlowDeploymentInit = AtLeast<FlowDeployment, 'id' | 'flow'>;
+export declare type FlowFunctionInit = AtLeast<Identity<FlowFunctionDto & {
+    id: string;
+}>, 'fqn' | 'id'>;
+export declare type FlowModuleInit = Replace<AtLeast<FlowModule, 'name'>, 'artifacts', ArtifactInit[]>;
+export declare type ArtifactInit = AtLeast<Artifact & {
+    path: string;
+}, 'filename' | 'path'>;
+export declare type FlowDiagramInit = AtLeast<FlowDiagram, 'id' | 'flow'>;
 export interface UserInit {
     roles: string[];
 }

package/dist/mock/api.mock.js

@@ -11,12 +11,17 @@ const secret_mock_service_1 = require("./secret.mock.service");
 const timeseries_mock_service_1 = require("./timeseries.mock.service");
 const task_mock_service_1 = require("./task.mock.service");
 const user_mock_service_1 = require("./user.mock.service");
+const flow_mock_service_1 = require("./flow.mock.service");
+const flow_deployment_mock_service_1 = require("./flow-deployment.mock.service");
+const flow_functions_mock_service_1 = require("./flow-functions.mock.service");
+const flow_modules_mock_service_1 = require("./flow-modules.mock.service");
+const crypto_1 = require("crypto");
 class MockAPI {
     constructor(initData) {
         this.httpClient = null;
         this.proxy = null;
         this.siDrive = null;
-        const { assets = [], contents = [], endpoints = [], secrets = [], timeSeries = [], tasks = [], events = [], users } = initData;
+        const { assets = [], revisions = [], contents = [], endpoints = [], secrets = [], timeSeries = [], tasks = [], events = [], users, flows = [], deployments = [], functions = [], modules = [], diagrams = [], } = initData;
         const assetTypes = assets
             .map((v) => v.type)
             .map((v) => {
@@ -32,6 +37,7 @@ class MockAPI {
                 };
         });
         const assets1 = assets.map((v, index) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], type: assetTypes[index] })));
+        const revisions1 = revisions.map((v, index) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], type: assetTypes[index] })));
         const contents1 = contents.map((v) => (Object.assign(Object.assign({}, v), { readPermissions: [], readWritePermissions: [], size: 0, fileId: '', mimetype: v.mimetype || '' })));
         const contentData = contents.map((v) => {
             return v.data ? v.data : (0, fs_1.readFileSync)((0, path_1.join)(v.filePath, v.filename));
@@ -90,7 +96,32 @@ class MockAPI {
             group: v.group,
         }));
         const timeseriesValues = timeSeries.map((v) => v.values);
-        this.assets = new asset_mock_service_1.AssetMockService(this, assets1);
+        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 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) => {
+            var _a;
+            return (Object.assign(Object.assign({}, v), { category: 'task', readPermissions: [], readWritePermissions: [], author: 'nobody', current: v.id, history: [v.id, ...((_a = v === null || v === void 0 ? void 0 : v.history) !== null && _a !== void 0 ? _a : [])] }));
+        });
+        const historyMap = new Map();
+        functions1.forEach((func) => {
+            func.history.forEach((hist) => {
+                if (historyMap.has(func.fqn)) {
+                    historyMap.get(func.fqn).push(functions1.find((v) => v.id === hist));
+                }
+                else {
+                    historyMap.set(func.fqn, [functions1.find((v) => v.id === hist)]);
+                }
+            });
+        });
+        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: [] }));
+        });
+        this.assets = new asset_mock_service_1.AssetMockService(this, assets1, revisions1);
         this.contents = new content_mock_service_1.ContentMockService(contents1, contentData);
         this.endpoints = new endpoint_mock_service_1.EndpointMockService(endpoint1);
         this.secrets = new secret_mock_service_1.SecretMockService(secrets1);
@@ -98,6 +129,10 @@ class MockAPI {
         this.tasks = new task_mock_service_1.TaskMockService(tasks1);
         this.events = new events_mock_service_1.EventsMockService(events1);
         this.users = new user_mock_service_1.UserMockService(users);
+        this.flows = new flow_mock_service_1.FlowMockService(flows1, diagrams1);
+        this.flowDeployments = new flow_deployment_mock_service_1.FlowDeploymentMockService(deployments1, this);
+        this.flowFunctions = new flow_functions_mock_service_1.FlowFunctionsMockService(functions1, historyMap);
+        this.flowModules = new flow_modules_mock_service_1.FlowModulesMockService(modules1);
         this.assetManager = this.assets;
         this.contentManager = this.contents;
         this.endpointManager = this.endpoints;

package/dist/mock/asset.mock.service.d.ts

@@ -1,12 +1,14 @@
 import FormData from 'form-data';
-import { Asset } from '../asset.interface';
+import { Asset, AssetRevision } from '../asset.interface';
 import { AssetService } from '../asset.service';
 import { Paginated, RequestParameter } from '../data.interface';
 import { MockAPI } from './api.mock';
 import { DataMockService } from './data.mock.service';
 export declare class AssetMockService extends DataMockService<Asset> implements AssetService {
     private api;
-    constructor(api: MockAPI, assets: Asset[]);
+    private revisions;
+    constructor(api: MockAPI, assets: Asset[], revisions: AssetRevision[]);
     addAttachment(id: string, form: FormData): Promise<Asset>;
     getChildren(assetId: string, params?: RequestParameter): Promise<Paginated<Asset[]>>;
+    findRevisions(assetId: string): Promise<Paginated<AssetRevision[]>>;
 }

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

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetMockService = void 0;
 const data_mock_service_1 = require("./data.mock.service");
 class AssetMockService extends data_mock_service_1.DataMockService {
-    constructor(api, assets) {
+    constructor(api, assets, revisions) {
         super();
         this.api = api;
+        this.revisions = [];
         this.data = assets;
+        this.revisions = revisions;
     }
     async addAttachment(id, form) {
         const asset = this.data.find((v) => v.id === id);
@@ -17,5 +19,14 @@ class AssetMockService extends data_mock_service_1.DataMockService {
     getChildren(assetId, params = {}) {
         return this.getManyFiltered({ parent: assetId }, params);
     }
+    findRevisions(assetId) {
+        const newData = this.revisions.filter((revision) => revision.originalId === assetId);
+        const page = {
+            docs: newData,
+            limit: Number.MAX_SAFE_INTEGER,
+            total: newData.length,
+        };
+        return Promise.resolve(page);
+    }
 }
 exports.AssetMockService = AssetMockService;

package/dist/mock/flow-deployment.mock.service.d.ts

@@ -0,0 +1,27 @@
+import { DataMockService } from './data.mock.service';
+import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from '../flow-deployment.interface';
+import { FlowDeploymentService } from '../flow-deployment.service';
+import { ResourceReference } from '../resource.interface';
+import { MockAPI } from './api.mock';
+export declare class FlowDeploymentMockService extends DataMockService<FlowDeployment> implements FlowDeploymentService {
+    private api;
+    constructor(deployments: FlowDeployment[], api: MockAPI);
+    subscribeToStatus(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent<any>) => void): Promise<string>;
+    subscribeToLogs(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
+    waitForRunningStatus(id: string): Promise<void>;
+    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted'): Promise<FlowDeployment>;
+    resolveReferences(id: string, recursive?: boolean, types?: string[]): Promise<ResourceReference[]>;
+    getDeploymentStatistics(id: string): Promise<FlowDeploymentStatistic>;
+    getDeploymentMetrics(id: string, range?: string, interval?: string): Promise<FlowDeploymentMetrics>;
+    getDeploymentLogs(id: string): Promise<FlowLog[]>;
+    addOne(dto: {
+        diagramId: string;
+        name: string;
+        properties?: Record<string, any>;
+        readPermissions?: string[];
+        readWritePermissions?: string[];
+        tags?: string[];
+    }): Promise<FlowDeployment>;
+    deleteOne(id: string): Promise<FlowDeployment>;
+    private getReferences;
+}

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowDeploymentMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+const crypto_1 = require("crypto");
+class FlowDeploymentMockService extends data_mock_service_1.DataMockService {
+    constructor(deployments, api) {
+        super();
+        this.api = api;
+        this.data = deployments;
+    }
+    subscribeToStatus(id, listener, errorListener) {
+        listener(new MessageEvent('message', { data: 'running' }));
+        return Promise.resolve((0, crypto_1.randomUUID)());
+    }
+    subscribeToLogs(id, listener, errorListener) {
+        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';
+    }
+    async updateStatus(id, desiredStatus) {
+        const deployment = await this.getOne(id);
+        deployment.desiredStatus = desiredStatus;
+        deployment.actualStatus = desiredStatus;
+        return Promise.resolve(deployment);
+    }
+    async resolveReferences(id, recursive, types) {
+        var _a;
+        const depl = await this.getOne(id);
+        return (_a = depl.refs) !== null && _a !== void 0 ? _a : [];
+    }
+    getDeploymentStatistics(id) {
+        return Promise.resolve({
+            totalErrorCount: 0,
+            errorCountWeek: 0,
+            eventCountWeek: 0,
+            errorCounts: [],
+            metrics: {
+                cpu: 0,
+                memory: 97931264,
+                ctime: 16770,
+                elapsed: 172850950,
+                timestamp: 1648199692625,
+                deploymentId: id,
+            },
+        });
+    }
+    getDeploymentMetrics(id, range, interval) {
+        return Promise.resolve({
+            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 },
+            },
+        });
+    }
+    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,
+            },
+        ]);
+    }
+    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, Object.assign(Object.assign({}, 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);
+        flow.deployments.splice(index, 1);
+        await this.api.flows.updateOne(flow.id, flow);
+        return super.deleteOne(id);
+    }
+    async getReferences(properties) {
+        return Promise.all(Object.keys(properties).map(async (prop) => {
+            switch (prop) {
+                case 'assetId':
+                    return { id: (await this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
+                default:
+                    throw new Error('not implemented');
+            }
+        }));
+    }
+}
+exports.FlowDeploymentMockService = FlowDeploymentMockService;

package/dist/mock/flow-functions.mock.service.d.ts

@@ -0,0 +1,14 @@
+import { DataMockService } from './data.mock.service';
+import { FlowFunctionDto } from '../flow-function.interface';
+import { FlowFunctionService } from '../flow-function.service';
+export declare class FlowFunctionsMockService extends DataMockService<FlowFunctionDto> implements FlowFunctionService {
+    private history;
+    constructor(functions: FlowFunctionDto[], history: Map<string, Array<FlowFunctionDto & {
+        id: string;
+    }>>);
+    getOneWithHistory(fqn: string): Promise<FlowFunctionDto>;
+    rollback(fqn: string, historyId: string): Promise<FlowFunctionDto>;
+    getOne(fqn: string, options?: any): Promise<FlowFunctionDto>;
+    private getOneById;
+    updateOne(fqn: string, dto: FlowFunctionDto): Promise<FlowFunctionDto>;
+}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowFunctionsMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+const crypto_1 = require("crypto");
+class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
+    constructor(functions, history) {
+        super();
+        this.history = history;
+        this.data = functions;
+    }
+    async getOneWithHistory(fqn) {
+        const func = await this.getOne(fqn);
+        return Promise.resolve(Object.assign(Object.assign({}, func), { history: await Promise.all(func.history.map(async (v) => {
+                const func1 = (await this.getOneById(v));
+                return { author: func1.author, createdAt: '', id: func1.id };
+            })) }));
+    }
+    rollback(fqn, historyId) {
+        const hist = this.history.get(fqn).find((v) => v.id === historyId);
+        const index = this.data.findIndex((v) => v.fqn === fqn);
+        hist.current = hist.id;
+        this.data[index] = hist;
+        return Promise.resolve(hist);
+    }
+    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);
+    }
+    async updateOne(fqn, dto) {
+        const id = (0, crypto_1.randomUUID)();
+        const exDto = Object.assign(Object.assign({}, dto), { id, current: id });
+        exDto.history.push(id);
+        this.history.get(fqn).push(exDto);
+        return exDto;
+    }
+}
+exports.FlowFunctionsMockService = FlowFunctionsMockService;

package/dist/mock/flow-modules.mock.service.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { DataMockService } from './data.mock.service';
+import { FlowModule } from '../flow-module.interface';
+import { FlowModuleService } from '../flow-module.service';
+import { ReadStream } from 'fs';
+import { Artifact } from '../storage.interface';
+import { Replace } from './api.mock';
+declare type ExtendedFlowModule = Replace<FlowModule, 'artifacts', Array<Artifact & {
+    path: string;
+}>>;
+export declare class FlowModulesMockService extends DataMockService<ExtendedFlowModule> implements FlowModuleService {
+    constructor(modules: ExtendedFlowModule[]);
+    deleteArtifact(name: string, version: string): Promise<FlowModule>;
+    download(name: string, filePath: string, version?: string): Promise<void>;
+    publish(file: ReadStream): Promise<unknown>;
+    getOne(name: string, options?: any): Promise<ExtendedFlowModule>;
+}
+export {};

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowModulesMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+const fs_1 = require("fs");
+const promises_1 = require("stream/promises");
+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);
+    }
+    async download(name, filePath, version = 'latest') {
+        var _a, _b;
+        const module = await this.getOne(name);
+        const reader = (0, fs_1.createReadStream)((_b = (_a = module.artifacts.find((art) => art.version === version)) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : module.artifacts[0].path);
+        const writer = (0, fs_1.createWriteStream)(filePath);
+        reader.pipe(writer);
+        return (0, promises_1.finished)(writer);
+    }
+    publish(file) {
+        return Promise.resolve(undefined);
+    }
+    getOne(name, options = {}) {
+        const t = this.data.find((v) => v.name === name);
+        return Promise.resolve(t);
+    }
+}
+exports.FlowModulesMockService = FlowModulesMockService;

package/dist/mock/flow.mock.service.d.ts

@@ -0,0 +1,10 @@
+import { DataMockService } from './data.mock.service';
+import { FlowDiagram, FlowDto } from '../flow.interface';
+import { FlowService } from '../flow.service';
+import { Paginated, RequestParameter } from '../data.interface';
+export declare class FlowMockService extends DataMockService<FlowDto> implements FlowService {
+    private diagrams;
+    constructor(flows: FlowDto[], diagrams: FlowDiagram[]);
+    getFlowWithDiagram(diagramId: string): Promise<FlowDto>;
+    getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowMockService = void 0;
+const data_mock_service_1 = require("./data.mock.service");
+class FlowMockService extends data_mock_service_1.DataMockService {
+    constructor(flows, diagrams) {
+        super();
+        this.diagrams = diagrams;
+        this.data = flows;
+    }
+    getFlowWithDiagram(diagramId) {
+        return Promise.resolve(this.data.find((v1) => v1.id === this.diagrams.find((v) => v.id === diagramId).flow));
+    }
+    async getMany(params) {
+        const flows = await super.getMany(params);
+        return {
+            docs: flows.docs.map((v) => (Object.assign(Object.assign({}, v), { diagram: this.diagrams.find((v1) => v1.id === v.diagram) }))),
+            total: 0,
+            limit: 0,
+        };
+    }
+}
+exports.FlowMockService = FlowMockService;

package/dist/mock/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./api.mock"), exports);
-(0, tslib_1.__exportStar)(require("./asset.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./assetTypes.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./content.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./data.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./secret.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./timeseries.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./task.mock.service"), exports);
-(0, tslib_1.__exportStar)(require("./events.mock.service"), exports);
+tslib_1.__exportStar(require("./api.mock"), exports);
+tslib_1.__exportStar(require("./asset.mock.service"), exports);
+tslib_1.__exportStar(require("./assetTypes.mock.service"), exports);
+tslib_1.__exportStar(require("./content.mock.service"), exports);
+tslib_1.__exportStar(require("./data.mock.service"), exports);
+tslib_1.__exportStar(require("./secret.mock.service"), exports);
+tslib_1.__exportStar(require("./timeseries.mock.service"), exports);
+tslib_1.__exportStar(require("./task.mock.service"), exports);
+tslib_1.__exportStar(require("./events.mock.service"), exports);

package/dist/resource.interface.d.ts

@@ -0,0 +1,18 @@
+export interface ResourceReference {
+    id: string;
+    resourceType: string;
+    dependent?: boolean;
+}
+export interface Resource {
+    id: string;
+    name: string;
+    readPermissions: string[];
+    readWritePermissions: string[];
+    description?: string;
+    author?: string;
+    tags?: string[];
+    refs?: ResourceReference[];
+    createdAt?: string | Date;
+    updatedAt?: string | Date;
+    deleteddAt?: string | Date;
+}

package/dist/resource.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/schema.interface.d.ts

@@ -0,0 +1,18 @@
+export interface JsonSchemaForm {
+    schema: JsonSchema;
+    layout: Record<string, any> | Record<string, any>[];
+}
+export declare type JsonSchemaTypeName = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+export declare type JsonSchemaType = string | number | boolean | {
+    [key: string]: JsonSchemaType;
+} | JsonSchemaArray | null;
+export declare type JsonSchemaArray = Array<JsonSchemaType>;
+export interface JsonSchema {
+    default?: JsonSchemaType;
+    description?: string;
+    items?: JsonSchema | JsonSchema[];
+    properties?: Record<string, JsonSchema>;
+    required?: boolean | string[];
+    title?: string;
+    type?: JsonSchemaTypeName | JsonSchemaTypeName[];
+}

package/dist/schema.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/storage.interface.d.ts

@@ -0,0 +1,16 @@
+export declare type FileType = 'original' | 'preview-sm' | 'preview-md' | 'preview-lg' | 'preview-xl';
+export declare type StorageProvider = 's3' | 'mongo';
+export interface Storage {
+    id: string;
+    filename: string;
+    mimetype: string;
+    size: number;
+    createdAt: string;
+    provider?: StorageProvider;
+    type?: FileType;
+    md5?: string;
+}
+export interface Artifact extends Storage {
+    version: string;
+    functions?: string[];
+}

package/dist/storage.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/user.service.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserService = void 0;
 const tslib_1 = require("tslib");
-const jwt_decode_1 = (0, tslib_1.__importDefault)(require("jwt-decode"));
+const jwt_decode_1 = tslib_1.__importDefault(require("jwt-decode"));
 class UserService {
     constructor(httpClient) {
         this.httpClient = httpClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hahnpro/hpc-api",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "description": "Module for easy access to the HahnPRO API",
   "license": "MIT",
   "author": {
@@ -24,13 +24,15 @@
     "access": "public"
   },
   "dependencies": {
-    "axios": "^0.25.0",
+    "axios": "^0.26.1",
+    "eventsource": "^2.0.0",
     "form-data": "^4.0.0",
     "jwt-decode": "^3.1.2",
     "p-queue": "^6.6.2"
   },
   "devDependencies": {
-    "axios-mock-adapter": "^1.20.0"
+    "axios-mock-adapter": "^1.20.0",
+    "@types/eventsource": "^1.1.8"
   },
   "engines": {
     "node": ">=v14.13"