@hahnpro/hpc-api 2.2.0 → 3.0.0

package/dist/asset.interface.d.ts

@@ -13,34 +13,35 @@ export interface AssetType {
     actions?: string[];
     createdAt?: string;
     updatedAt?: string;
+    author?: string;
+    revision?: number;
 }
-export interface AssetParent {
+export declare type AssetTypeRevision = AssetType & {
+    originalId: string;
+};
+export interface Asset {
     id?: string;
     name: string;
     type: string | AssetType;
+    type$name?: string;
     readPermissions: string[];
     readWritePermissions: string[];
     parent?: any | Asset;
+    parent$name?: string;
     ancestors?: string[];
     tags?: string[];
     relations?: any[];
     data?: any;
     image?: string;
-    author?: string;
-    revision?: number;
-}
-export interface Asset extends AssetParent {
-    type$name?: string;
-    parent$name?: string;
     attachments?: string[];
     notificationEndpoints?: string[];
     actions?: string[];
+    author?: string;
+    revision?: number;
 }
-export interface AssetRevision extends AssetParent {
-    originalId?: string;
-    createdAt?: string;
-    updatedAt?: string;
-}
+export declare type AssetRevision = Asset & {
+    originalId: string;
+};
 export interface Attachment {
     id?: string;
     filename: string;
@@ -61,4 +62,9 @@ export interface Action {
     responseType?: string;
     readPermissions: string[];
     readWritePermissions: string[];
+    author?: string;
+    revision?: number;
 }
+export declare type ActionRevision = Action & {
+    originalId: string;
+};

package/dist/asset.service.d.ts

@@ -7,5 +7,7 @@ export declare class AssetService extends DataService<Asset> {
     constructor(httpClient: HttpClient);
     addAttachment: (id: string, form: FormData) => Promise<Asset>;
     getChildren(assetId: string, params?: RequestParameter): Promise<Paginated<Asset[]>>;
-    findRevisions(assetId: string): Promise<Paginated<AssetRevision[]>>;
+    getRevisions(assetId: string): Promise<Paginated<AssetRevision[]>>;
+    rollback(assetId: string, revisionId: string): Promise<Asset>;
+    deleteRevision(assetId: string, revisionId: string): Promise<any>;
 }

package/dist/asset.service.js

@@ -17,8 +17,14 @@ class AssetService extends data_service_1.DataService {
     getChildren(assetId, params = {}) {
         return this.getManyFiltered({ parent: assetId }, params);
     }
-    findRevisions(assetId) {
+    getRevisions(assetId) {
         return this.httpClient.get(`${this.basePath}/${assetId}/revisions`);
     }
+    rollback(assetId, revisionId) {
+        return this.httpClient.put(`${this.basePath}/${assetId}/rollback`, { revisionId });
+    }
+    deleteRevision(assetId, revisionId) {
+        return this.httpClient.delete(`${this.basePath}/${assetId}/revisions/${revisionId}`);
+    }
 }
 exports.AssetService = AssetService;

package/dist/assettypes.service.d.ts

@@ -1,6 +1,10 @@
 import { AssetType } from './asset.interface';
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
+import { Paginated } from './data.interface';
 export declare class AssetTypesService extends DataService<AssetType> {
     constructor(httpClient: HttpClient);
+    getRevisions(id: string): Promise<Paginated<AssetType[]>>;
+    rollback(id: string, revisionId: string): Promise<AssetType>;
+    deleteRevision(id: string, revisionId: string): Promise<any>;
 }

package/dist/assettypes.service.js

@@ -6,5 +6,14 @@ class AssetTypesService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/assettypes');
     }
+    getRevisions(id) {
+        return this.httpClient.get(`${this.basePath}/${id}/revisions`);
+    }
+    rollback(id, revisionId) {
+        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId });
+    }
+    deleteRevision(id, revisionId) {
+        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`);
+    }
 }
 exports.AssetTypesService = AssetTypesService;

package/dist/content.service.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import FormData from 'form-data';
 import { Content, ReturnType } from './content.interface';
 import { DataService } from './data.service';

package/dist/content.service.js

@@ -13,7 +13,7 @@ class ContentService extends data_service_1.DataService {
     }
     async download(id, second) {
         let returnType;
-        if (typeof second === 'boolean' || !second) {
+        if (typeof second === 'boolean' || second == null) {
             returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
         }
         else {

package/dist/flow-function.interface.d.ts

@@ -4,8 +4,6 @@ export interface FlowFunctionDto {
     readPermissions: string[];
     readWritePermissions: string[];
     author: string;
-    current: string;
-    history: string[] | HistoryEntry[];
     name?: string;
     description?: string;
     icon?: string;
@@ -17,12 +15,12 @@ export interface FlowFunctionDto {
     tags?: string[];
     createdAt?: string;
     updatedAt?: string;
+    revision?: string;
 }
-export interface HistoryEntry {
-    author: string;
-    createdAt: string;
+export declare type FlowFunctionRevision = FlowFunctionDto & {
     id: string;
-}
+    originalId: string;
+};
 interface Stream {
     name: string;
 }

package/dist/flow-function.service.d.ts

@@ -1,9 +1,11 @@
 import { DataService } from './data.service';
 import { FlowFunctionDto } from './flow-function.interface';
 import { HttpClient } from './http.service';
+import { Paginated } from './data.interface';
 export declare class FlowFunctionService extends DataService<FlowFunctionDto> {
     constructor(httpClient: HttpClient);
     addMany(dto: any[]): Promise<FlowFunctionDto[]>;
-    getOneWithHistory(fqn: string): Promise<FlowFunctionDto>;
-    rollback(fqn: string, historyId: string): Promise<FlowFunctionDto>;
+    getRevisions(fqn: string): Promise<Paginated<FlowFunctionDto[]>>;
+    rollback(fqn: string, revisionId: string): Promise<FlowFunctionDto>;
+    deleteRevision(fqn: string, revisionId: string): Promise<any>;
 }

package/dist/flow-function.service.js

@@ -10,11 +10,14 @@ class FlowFunctionService extends data_service_1.DataService {
         const reqs = dto.map((v) => this.addOne(v));
         return Promise.all(reqs);
     }
-    getOneWithHistory(fqn) {
-        return this.httpClient.get(`${this.basePath}/${fqn}/history`);
+    getRevisions(fqn) {
+        return this.httpClient.get(`${this.basePath}/${fqn}/revisions`);
     }
-    rollback(fqn, historyId) {
-        return this.httpClient.put(`${this.basePath}/${fqn}/rollback/${historyId}`, {});
+    rollback(fqn, revisionId) {
+        return this.httpClient.put(`${this.basePath}/${fqn}/rollback`, { revisionId });
+    }
+    deleteRevision(fqn, revisionId) {
+        return this.httpClient.delete(`${this.basePath}/${fqn}/revisions/${revisionId}`);
     }
 }
 exports.FlowFunctionService = FlowFunctionService;

package/dist/flow-module.service.d.ts

@@ -1,13 +1,11 @@
-/// <reference types="node" />
 import { DataService } from './data.service';
 import { FlowModule } from './flow-module.interface';
 import { HttpClient } from './http.service';
-import { ReadStream } from 'fs';
+import FormData from 'form-data';
 export declare class FlowModuleService extends DataService<FlowModule> {
     constructor(httpClient: HttpClient);
     deleteArtifact(name: string, version: string): Promise<FlowModule>;
-    download(name: string, filePath: string, version?: string): Promise<void>;
-    publish(file: ReadStream): Promise<unknown>;
+    publish(form: FormData): Promise<unknown>;
     addOne(dto: any): Promise<FlowModule>;
     addMany(dto: any[]): Promise<FlowModule[]>;
 }

package/dist/flow-module.service.js

@@ -1,11 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowModuleService = void 0;
-const tslib_1 = require("tslib");
 const data_service_1 = require("./data.service");
-const fs_1 = require("fs");
-const form_data_1 = tslib_1.__importDefault(require("form-data"));
-const promises_1 = require("stream/promises");
 class FlowModuleService extends data_service_1.DataService {
     constructor(httpClient) {
         super(httpClient, '/flow/modules');
@@ -13,16 +9,7 @@ class FlowModuleService extends data_service_1.DataService {
     deleteArtifact(name, version) {
         return this.httpClient.delete(`${this.basePath}/${name}/${version}`);
     }
-    async download(name, filePath, version = 'latest') {
-        const writer = (0, fs_1.createWriteStream)(filePath);
-        return this.httpClient.get(`${this.basePath}/${name}/${version}`, { responseType: 'stream' }).then(async (response) => {
-            response.pipe(writer);
-            return (0, promises_1.finished)(writer);
-        });
-    }
-    publish(file) {
-        const form = new form_data_1.default();
-        form.append('file', file);
+    publish(form) {
         const config = {
             headers: Object.assign({}, form.getHeaders()),
             maxBodyLength: Infinity,

package/dist/flow.interface.d.ts

@@ -7,6 +7,9 @@ export interface FlowDto extends Resource {
     dashboard?: DashboardItem[];
     propertiesSchema?: JsonSchemaForm;
 }
+export declare type FlowRevision = FlowDto & {
+    originalId: string;
+};
 export interface DashboardItem {
     id: string;
     cols: number;

package/dist/flow.service.d.ts

@@ -1,11 +1,17 @@
 import { DataService } from './data.service';
-import { FlowDto } from './flow.interface';
+import { FlowDiagram, FlowDto } from './flow.interface';
 import { HttpClient } from './http.service';
 import { Paginated, RequestParameter } from './data.interface';
+import { FlowDeployment } from './flow-deployment.interface';
 export declare class FlowService extends DataService<FlowDto> {
     constructor(httpClient: HttpClient);
     addMany(dto: any[]): Promise<FlowDto[]>;
     getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;
     getOne(id: string, options?: any): Promise<FlowDto>;
     getFlowWithDiagram(diagramId: string): Promise<FlowDto>;
+    getDiagramRevisions(id: string): Promise<FlowDiagram[]>;
+    isDeploymentOnLatestDiagramVersion(depl: FlowDeployment): Promise<boolean>;
+    getRevisions(id: string): Promise<Paginated<FlowDto[]>>;
+    rollback(id: string, revisionId: string): Promise<FlowDto>;
+    deleteRevision(id: string, revisionId: string): Promise<any>;
 }

package/dist/flow.service.js

@@ -21,5 +21,23 @@ class FlowService extends data_service_1.DataService {
     getFlowWithDiagram(diagramId) {
         return this.httpClient.get(`${this.basePath}/diagram/${diagramId}`);
     }
+    getDiagramRevisions(id) {
+        return this.httpClient.get(`${this.basePath}/${id}/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.reverse()[0].id === diagramId;
+    }
+    getRevisions(id) {
+        return this.httpClient.get(`${this.basePath}/${id}/revisions`);
+    }
+    rollback(id, revisionId) {
+        return this.httpClient.put(`${this.basePath}/${id}/rollback`, { revisionId });
+    }
+    deleteRevision(id, revisionId) {
+        return this.httpClient.delete(`${this.basePath}/${id}/revisions/${revisionId}`);
+    }
 }
 exports.FlowService = FlowService;

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

@@ -19,9 +19,9 @@ 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 { FlowDiagram, FlowDto, FlowRevision } from '../flow.interface';
 import { FlowDeployment } from '../flow-deployment.interface';
-import { FlowFunctionDto } from '../flow-function.interface';
+import { FlowFunctionDto, FlowFunctionRevision } from '../flow-function.interface';
 import { FlowModule } from '../flow-module.interface';
 import { Artifact } from '../storage.interface';
 export declare class MockAPI implements API {
@@ -51,7 +51,7 @@ export declare class MockAPI implements API {
     userManager: UserMockService;
     constructor(initData: {
         assets?: AssetInit[];
-        revisions?: AssetRevisionInit[];
+        assetRevisions?: AssetRevisionInit[];
         contents?: ContentInit[];
         endpoints?: EndpointInit[];
         secrets?: SecretInit[];
@@ -60,8 +60,10 @@ export declare class MockAPI implements API {
         events?: EventInit[];
         users?: UserInit;
         flows?: FlowInit[];
+        flowRevisions?: FlowRevisionInit[];
         deployments?: FlowDeploymentInit[];
         functions?: FlowFunctionInit[];
+        functionRevisions?: FlowFunctionRevisionInit[];
         modules?: FlowModuleInit[];
         diagrams?: FlowDiagramInit[];
     });
@@ -74,7 +76,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 AssetRevisionInit = Replace<AtLeast<AssetRevision, 'id' | 'name' | 'type' | 'originalId'>, 'type', AssetTypeInit | string>;
 export declare type AssetTypeInit = AtLeast<AssetType, 'id' | 'name'>;
 export declare type ContentInit = Identity<AtLeast<Content, 'id' | 'filename'> & {
     filePath?: string;
@@ -88,10 +90,10 @@ 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 FlowRevisionInit = AtLeast<FlowRevision, 'id' | 'originalId'>;
 export declare type FlowDeploymentInit = AtLeast<FlowDeployment, 'id' | 'flow'>;
-export declare type FlowFunctionInit = AtLeast<Identity<FlowFunctionDto & {
-    id: string;
-}>, 'fqn' | 'id'>;
+export declare type FlowFunctionInit = AtLeast<FlowFunctionDto, 'fqn'>;
+export declare type FlowFunctionRevisionInit = AtLeast<FlowFunctionRevision, 'fqn' | 'id' | 'originalId'>;
 export declare type FlowModuleInit = Replace<AtLeast<FlowModule, 'name'>, 'artifacts', ArtifactInit[]>;
 export declare type ArtifactInit = AtLeast<Artifact & {
     path: string;

package/dist/mock/api.mock.js

@@ -21,7 +21,7 @@ class MockAPI {
         this.httpClient = null;
         this.proxy = null;
         this.siDrive = null;
-        const { assets = [], revisions = [], contents = [], endpoints = [], secrets = [], timeSeries = [], tasks = [], events = [], users, flows = [], deployments = [], functions = [], modules = [], diagrams = [], } = initData;
+        const { assets = [], assetRevisions = [], contents = [], endpoints = [], secrets = [], timeSeries = [], tasks = [], events = [], users, flows = [], flowRevisions = [], deployments = [], functions = [], functionRevisions = [], modules = [], diagrams = [], } = initData;
         const assetTypes = assets
             .map((v) => v.type)
             .map((v) => {
@@ -37,7 +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 assetRevisions1 = assetRevisions.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));
@@ -98,30 +98,18 @@ class MockAPI {
         const timeseriesValues = timeSeries.map((v) => v.values);
         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) => {
-            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 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: [] }));
         });
-        this.assets = new asset_mock_service_1.AssetMockService(this, assets1, revisions1);
+        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);
         this.secrets = new secret_mock_service_1.SecretMockService(secrets1);
@@ -129,9 +117,9 @@ 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.flows = new flow_mock_service_1.FlowMockService(flows1, diagrams1, flowRevisions1);
         this.flowDeployments = new flow_deployment_mock_service_1.FlowDeploymentMockService(deployments1, this);
-        this.flowFunctions = new flow_functions_mock_service_1.FlowFunctionsMockService(functions1, historyMap);
+        this.flowFunctions = new flow_functions_mock_service_1.FlowFunctionsMockService(functions1, functionRevisions1);
         this.flowModules = new flow_modules_mock_service_1.FlowModulesMockService(modules1);
         this.assetManager = this.assets;
         this.contentManager = this.contents;

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

@@ -8,7 +8,12 @@ export declare class AssetMockService extends DataMockService<Asset> implements
     private api;
     private revisions;
     constructor(api: MockAPI, assets: Asset[], revisions: AssetRevision[]);
+    addOne(dto: Asset): Promise<Asset>;
+    deleteOne(assetId: string): Promise<any>;
+    updateOne(assetId: string, dto: Asset): Promise<Asset>;
     addAttachment(id: string, form: FormData): Promise<Asset>;
     getChildren(assetId: string, params?: RequestParameter): Promise<Paginated<Asset[]>>;
-    findRevisions(assetId: string): Promise<Paginated<AssetRevision[]>>;
+    getRevisions(assetId: string): Promise<Paginated<AssetRevision[]>>;
+    rollback(assetId: string, revisionId: string): Promise<Asset>;
+    deleteRevision(assetId: string, revisionId: string): Promise<any>;
 }

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

@@ -2,13 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetMockService = void 0;
 const data_mock_service_1 = require("./data.mock.service");
+const crypto_1 = require("crypto");
 class AssetMockService extends data_mock_service_1.DataMockService {
     constructor(api, assets, revisions) {
         super();
         this.api = api;
-        this.revisions = [];
-        this.data = assets;
         this.revisions = revisions;
+        this.data = assets;
+    }
+    addOne(dto) {
+        const id = (0, crypto_1.randomUUID)();
+        this.revisions.push(Object.assign(Object.assign({}, dto), { originalId: dto.id }));
+        return super.addOne(dto);
+    }
+    deleteOne(assetId) {
+        this.revisions
+            .filter((revision) => revision.originalId === assetId)
+            .forEach((revision) => {
+            const index = this.revisions.indexOf(revision);
+            this.revisions.splice(index, 1);
+        });
+        return super.deleteOne(assetId);
+    }
+    async updateOne(assetId, dto) {
+        await super.deleteOne(assetId);
+        const asset = await this.addOne(dto);
+        return Promise.resolve(asset);
     }
     async addAttachment(id, form) {
         const asset = this.data.find((v) => v.id === id);
@@ -19,14 +38,23 @@ 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);
+    getRevisions(assetId) {
+        const revisions = this.revisions.filter((revision) => revision.originalId === assetId);
         const page = {
-            docs: newData,
+            docs: revisions,
             limit: Number.MAX_SAFE_INTEGER,
-            total: newData.length,
+            total: revisions.length,
         };
         return Promise.resolve(page);
     }
+    rollback(assetId, revisionId) {
+        const asset = this.revisions.find((revision) => revision.id === revisionId);
+        return Promise.resolve(asset);
+    }
+    deleteRevision(assetId, revisionId) {
+        const index = this.revisions.findIndex((revision) => revision.id === revisionId);
+        this.revisions.splice(index, 1);
+        return Promise.resolve(revisionId);
+    }
 }
 exports.AssetMockService = AssetMockService;

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

@@ -1,6 +1,14 @@
-import { AssetType } from '../asset.interface';
+import { AssetType, AssetTypeRevision } from '../asset.interface';
 import { AssetTypesService } from '../assettypes.service';
 import { DataMockService } from './data.mock.service';
+import { Paginated } from '../data.interface';
 export declare class AssetTypesMockService extends DataMockService<AssetType> implements AssetTypesService {
-    constructor(assetTypes: AssetType[]);
+    private revisions;
+    constructor(assetTypes: AssetType[], revisions: AssetTypeRevision[]);
+    addOne(dto: AssetType): Promise<AssetType>;
+    deleteOne(id: string): Promise<any>;
+    updateOne(id: string, dto: AssetType): Promise<AssetType>;
+    getRevisions(id: string): Promise<Paginated<AssetTypeRevision[]>>;
+    rollback(id: string, revisionId: string): Promise<AssetType>;
+    deleteRevision(assetId: string, revisionId: string): Promise<any>;
 }

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

@@ -2,10 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetTypesMockService = void 0;
 const data_mock_service_1 = require("./data.mock.service");
+const crypto_1 = require("crypto");
 class AssetTypesMockService extends data_mock_service_1.DataMockService {
-    constructor(assetTypes) {
+    constructor(assetTypes, revisions) {
         super();
+        this.revisions = revisions;
         this.data = assetTypes;
     }
+    addOne(dto) {
+        const id = (0, crypto_1.randomUUID)();
+        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.id }));
+        return super.addOne(dto);
+    }
+    deleteOne(id) {
+        this.revisions
+            .filter((revision) => revision.originalId === id)
+            .forEach((revision) => {
+            const index = this.revisions.indexOf(revision);
+            this.revisions.splice(index, 1);
+        });
+        return super.deleteOne(id);
+    }
+    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);
+        const page = {
+            docs: revisions,
+            limit: Number.MAX_SAFE_INTEGER,
+            total: revisions.length,
+        };
+        return Promise.resolve(page);
+    }
+    rollback(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);
+        this.revisions.splice(index, 1);
+        return Promise.resolve(revisionId);
+    }
 }
 exports.AssetTypesMockService = AssetTypesMockService;

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import FormData from 'form-data';
 import { Readable } from 'stream';
 import { Content, ReturnType } from '../content.interface';

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

@@ -15,7 +15,7 @@ class ContentMockService extends data_mock_service_1.DataMockService {
     }
     download(id, second) {
         let returnType;
-        if (typeof second === 'boolean' || !second) {
+        if (typeof second === 'boolean' || second == null) {
             returnType = second ? content_interface_1.ReturnType.ARRAYBUFFER : content_interface_1.ReturnType.BLOB;
         }
         else {

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

@@ -1,14 +1,16 @@
 import { DataMockService } from './data.mock.service';
-import { FlowFunctionDto } from '../flow-function.interface';
+import { FlowFunctionDto, FlowFunctionRevision } from '../flow-function.interface';
 import { FlowFunctionService } from '../flow-function.service';
+import { Paginated } from '../data.interface';
 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>;
+    private revisions;
+    constructor(functions: FlowFunctionDto[], revisions: FlowFunctionRevision[]);
+    addOne(dto: FlowFunctionDto): Promise<FlowFunctionDto>;
+    deleteOne(fqn: string): Promise<any>;
+    updateOne(fqn: string, dto: FlowFunctionDto): Promise<FlowFunctionDto>;
     getOne(fqn: string, options?: any): Promise<FlowFunctionDto>;
     private getOneById;
-    updateOne(fqn: string, dto: FlowFunctionDto): Promise<FlowFunctionDto>;
+    getRevisions(fqn: string): Promise<Paginated<FlowFunctionRevision[]>>;
+    rollback(fqn: string, revisionId: string): Promise<FlowFunctionDto>;
+    deleteRevision(fqn: string, revisionId: string): Promise<any>;
 }

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

@@ -4,24 +4,32 @@ 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) {
+    constructor(functions, revisions) {
         super();
-        this.history = history;
+        this.revisions = revisions;
         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 };
-            })) }));
+    addOne(dto) {
+        const id = (0, crypto_1.randomUUID)();
+        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.fqn }));
+        return super.addOne(dto);
+    }
+    deleteOne(fqn) {
+        const index = this.data.findIndex((v) => v.fqn === fqn);
+        this.data.splice(index, 1);
+        this.revisions
+            .filter((revision) => revision.originalId === fqn)
+            .forEach((revision) => {
+            const index = this.revisions.indexOf(revision);
+            this.revisions.splice(index, 1);
+        });
+        return Promise.resolve(undefined);
     }
-    rollback(fqn, historyId) {
-        const hist = this.history.get(fqn).find((v) => v.id === historyId);
+    async updateOne(fqn, dto) {
         const index = this.data.findIndex((v) => v.fqn === fqn);
-        hist.current = hist.id;
-        this.data[index] = hist;
-        return Promise.resolve(hist);
+        this.data.splice(index, 1);
+        const flowFunction = await this.addOne(dto);
+        return Promise.resolve(flowFunction);
     }
     getOne(fqn, options) {
         const t = this.data.find((v) => v.fqn === fqn);
@@ -30,12 +38,23 @@ class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
     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;
+    getRevisions(fqn) {
+        const revisions = this.revisions.filter((revision) => revision.originalId === fqn);
+        const page = {
+            docs: revisions,
+            limit: Number.MAX_SAFE_INTEGER,
+            total: revisions.length,
+        };
+        return Promise.resolve(page);
+    }
+    rollback(fqn, revisionId) {
+        const assetType = this.revisions.find((revision) => revision.id === revisionId);
+        return Promise.resolve(assetType);
+    }
+    deleteRevision(fqn, revisionId) {
+        const index = this.revisions.findIndex((revision) => revision.id === revisionId);
+        this.revisions.splice(index, 1);
+        return Promise.resolve(revisionId);
     }
 }
 exports.FlowFunctionsMockService = FlowFunctionsMockService;

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

@@ -1,18 +1,16 @@
-/// <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';
+import FormData from 'form-data';
 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>;
+    publish(form: FormData): Promise<unknown>;
     getOne(name: string, options?: any): Promise<ExtendedFlowModule>;
 }
 export {};

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

@@ -2,8 +2,6 @@
 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();
@@ -15,15 +13,7 @@ class FlowModulesMockService extends data_mock_service_1.DataMockService {
         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) {
+    publish(form) {
         return Promise.resolve(undefined);
     }
     getOne(name, options = {}) {

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

@@ -1,10 +1,20 @@
 import { DataMockService } from './data.mock.service';
-import { FlowDiagram, FlowDto } from '../flow.interface';
+import { FlowDiagram, FlowDto, FlowRevision } from '../flow.interface';
 import { FlowService } from '../flow.service';
 import { Paginated, RequestParameter } from '../data.interface';
+import { FlowDeployment } from '../flow-deployment.interface';
 export declare class FlowMockService extends DataMockService<FlowDto> implements FlowService {
     private diagrams;
-    constructor(flows: FlowDto[], diagrams: FlowDiagram[]);
+    private revisions;
+    constructor(flows: FlowDto[], diagrams: FlowDiagram[], revisions: FlowRevision[]);
+    addOne(dto: FlowDto): Promise<FlowDto>;
+    deleteOne(id: string): Promise<any>;
+    updateOne(id: string, dto: FlowDto): Promise<FlowDto>;
+    isDeploymentOnLatestDiagramVersion(depl: FlowDeployment): Promise<boolean>;
+    getDiagramRevisions(id: string): Promise<FlowDiagram[]>;
     getFlowWithDiagram(diagramId: string): Promise<FlowDto>;
     getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;
+    getRevisions(id: string): Promise<Paginated<FlowRevision[]>>;
+    rollback(id: string, revisionId: string): Promise<FlowDto>;
+    deleteRevision(id: string, revisionId: string): Promise<any>;
 }

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

@@ -2,12 +2,42 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowMockService = void 0;
 const data_mock_service_1 = require("./data.mock.service");
+const crypto_1 = require("crypto");
 class FlowMockService extends data_mock_service_1.DataMockService {
-    constructor(flows, diagrams) {
+    constructor(flows, diagrams, revisions) {
         super();
         this.diagrams = diagrams;
+        this.revisions = revisions;
         this.data = flows;
     }
+    addOne(dto) {
+        const id = (0, crypto_1.randomUUID)();
+        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.id }));
+        return super.addOne(dto);
+    }
+    deleteOne(id) {
+        this.revisions
+            .filter((revision) => revision.originalId === id)
+            .forEach((revision) => {
+            const index = this.revisions.indexOf(revision);
+            this.revisions.splice(index, 1);
+        });
+        return super.deleteOne(id);
+    }
+    async updateOne(id, dto) {
+        await super.deleteOne(id);
+        const flow = await 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.reverse()[0].id === diagramId;
+    }
+    getDiagramRevisions(id) {
+        return Promise.resolve(this.diagrams.filter((v) => v.flow === id));
+    }
     getFlowWithDiagram(diagramId) {
         return Promise.resolve(this.data.find((v1) => v1.id === this.diagrams.find((v) => v.id === diagramId).flow));
     }
@@ -19,5 +49,23 @@ class FlowMockService extends data_mock_service_1.DataMockService {
             limit: 0,
         };
     }
+    getRevisions(id) {
+        const revisions = this.revisions.filter((revision) => revision.originalId === id);
+        const page = {
+            docs: revisions,
+            limit: Number.MAX_SAFE_INTEGER,
+            total: revisions.length,
+        };
+        return Promise.resolve(page);
+    }
+    rollback(id, revisionId) {
+        const flow = this.revisions.find((revision) => revision.id === revisionId);
+        return Promise.resolve(flow);
+    }
+    deleteRevision(id, revisionId) {
+        const index = this.revisions.findIndex((revision) => revision.id === revisionId);
+        this.revisions.splice(index, 1);
+        return Promise.resolve(revisionId);
+    }
 }
 exports.FlowMockService = FlowMockService;

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

@@ -30,7 +30,7 @@ class TimeseriesMockService extends data_mock_service_1.DataMockService {
     }
     async addValue(id, value) {
         const ts = await this.getOne(id, {});
-        ts.data.push({ timestamp: new Date().getDate(), value });
+        ts.data.push({ timestamp: new Date().valueOf(), value });
         return;
     }
     getManyByAsset(assetId, names) {
@@ -49,13 +49,13 @@ class TimeseriesMockService extends data_mock_service_1.DataMockService {
     async getMostRecentValue(id, before) {
         const ts = await this.getOne(id, {});
         for (const datum of ts.data) {
-            if (datum.timestamp < before.getDate()) {
+            if (datum.timestamp < before.valueOf()) {
                 return datum;
             }
         }
     }
     async getValues(id, from, limit, group) {
-        let timeSeriesValues = await this.getValuesOfPeriod(id, from, new Date().getDate(), group);
+        let timeSeriesValues = await this.getValuesOfPeriod(id, from, new Date().valueOf(), group);
         if (limit) {
             timeSeriesValues = timeSeriesValues.slice(0, limit);
         }

package/dist/resource.interface.d.ts

@@ -15,4 +15,5 @@ export interface Resource {
     createdAt?: string | Date;
     updatedAt?: string | Date;
     deleteddAt?: string | Date;
+    revision?: string;
 }

package/package.json

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