@hahnpro/hpc-api 3.2.1 → 3.4.1

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

@@ -1,20 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetTypesMockService = void 0;
-const data_mock_service_1 = require("./data.mock.service");
+const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
-class AssetTypesMockService extends data_mock_service_1.DataMockService {
+const ts_mixer_1 = require("ts-mixer");
+const api_base_mock_1 = require("./api-base.mock");
+const data_mock_service_1 = require("./data.mock.service");
+const trash_mock_service_1 = require("./trash.mock.service");
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class AssetTypesMockService extends BaseService {
     constructor(assetTypes, revisions) {
-        super();
+        super(assetTypes);
         this.revisions = revisions;
-        this.data = assetTypes;
+    }
+    getMany(params) {
+        const page = this.getItems(params, false);
+        return Promise.resolve(page);
     }
     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) {
+    deleteOne(id, force = false) {
+        const assettype = this.data.find((v) => v.id === id);
+        if (!(assettype === null || assettype === void 0 ? void 0 : assettype.deletedAt) && !force) {
+            assettype.deletedAt = new Date().toISOString();
+            return Promise.resolve(assettype);
+        }
         this.revisions
             .filter((revision) => revision.originalId === id)
             .forEach((revision) => {

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

@@ -4,8 +4,15 @@ import FormData from 'form-data';
 import { Readable } from 'stream';
 import { Content, ReturnType } from '../content.interface';
 import { ContentService } from '../content.service';
+import { Paginated, RequestParameter } from '../data.interface';
+import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
-export declare class ContentMockService extends DataMockService<Content> implements ContentService {
+import { TrashMockService } from './trash.mock.service';
+interface BaseService extends DataMockService<Content>, TrashMockService<Content> {
+}
+declare class BaseService extends APIBaseMock<Content> {
+}
+export declare class ContentMockService extends BaseService implements ContentService {
     private contentData;
     constructor(contents: Content[], contentData: any[]);
     download(id: string, raw?: boolean): Promise<Blob | ArrayBuffer>;
@@ -15,5 +22,8 @@ export declare class ContentMockService extends DataMockService<Content> impleme
     download(id: string, returnType: ReturnType.BLOB): Promise<Blob>;
     download(id: string, returnType: ReturnType.ARRAYBUFFER): Promise<ArrayBuffer>;
     download(id: string, returnType: ReturnType.NODESTREAM): Promise<Readable>;
+    deleteOne(contentId: string, force?: boolean): Promise<Content>;
+    getMany(params?: RequestParameter): Promise<Paginated<Content[]>>;
     upload(form: FormData): Promise<Content>;
 }
+export {};

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

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentMockService = void 0;
+const tslib_1 = require("tslib");
 const stream_1 = require("stream");
+const ts_mixer_1 = require("ts-mixer");
 const content_interface_1 = require("../content.interface");
+const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
-class ContentMockService extends data_mock_service_1.DataMockService {
+const trash_mock_service_1 = require("./trash.mock.service");
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class ContentMockService extends BaseService {
     constructor(contents, contentData) {
-        super();
+        super(contents);
         this.contentData = new Map();
-        this.data = contents;
         for (let i = 0; i < contents.length; i++) {
             this.contentData.set(contents[i].id, contentData[i]);
         }
@@ -57,6 +65,18 @@ class ContentMockService extends data_mock_service_1.DataMockService {
                 return Promise.resolve(stream_1.Readable.from(this.contentData.get(id)));
         }
     }
+    deleteOne(contentId, force = false) {
+        const content = this.data.find((v) => v.id === contentId);
+        if (!(content === null || content === void 0 ? void 0 : content.deletedAt) && !force) {
+            content.deletedAt = new Date().toISOString();
+            return Promise.resolve(content);
+        }
+        return super.deleteOne(contentId);
+    }
+    getMany(params) {
+        const page = this.getItems(params, false);
+        return Promise.resolve(page);
+    }
     upload(form) {
         return Promise.resolve(undefined);
     }

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

@@ -1,7 +1,8 @@
 import { Filter, Paginated, RequestParameter } from '../data.interface';
 import { DataService } from '../data.service';
-export declare class DataMockService<T> extends DataService<T> {
-    protected data: T[];
+import { APIBaseMock } from './api-base.mock';
+export declare class DataMockService<T> extends DataService<T> implements APIBaseMock<T> {
+    data: T[];
     constructor();
     addMany(dto: any[]): Promise<T[]>;
     addOne(dto: any): Promise<T>;

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

@@ -1,15 +1,21 @@
-import { DataMockService } from './data.mock.service';
-import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from '../flow-deployment.interface';
 import { FlowDeploymentService } from '../flow-deployment.service';
+import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from '../flow-deployment.interface';
 import { ResourceReference } from '../resource.interface';
 import { MockAPI } from './api.mock';
-export declare class FlowDeploymentMockService extends DataMockService<FlowDeployment> implements FlowDeploymentService {
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+interface BaseService extends DataMockService<FlowDeployment>, TrashMockService<FlowDeployment> {
+}
+declare class BaseService extends APIBaseMock<FlowDeployment> {
+}
+export declare class FlowDeploymentMockService extends BaseService 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>;
+    updateStatus(id: string, desiredStatus: 'running' | 'stopped' | 'deleted' | 'paused'): 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>;
@@ -25,3 +31,4 @@ export declare class FlowDeploymentMockService extends DataMockService<FlowDeplo
     deleteOne(id: string): Promise<FlowDeployment>;
     private getReferences;
 }
+export {};

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

@@ -1,13 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowDeploymentMockService = void 0;
-const data_mock_service_1 = require("./data.mock.service");
+const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
-class FlowDeploymentMockService extends data_mock_service_1.DataMockService {
+const ts_mixer_1 = require("ts-mixer");
+const api_base_mock_1 = require("./api-base.mock");
+const data_mock_service_1 = require("./data.mock.service");
+const trash_mock_service_1 = require("./trash.mock.service");
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class FlowDeploymentMockService extends BaseService {
     constructor(deployments, api) {
-        super();
+        super(deployments);
         this.api = api;
-        this.data = deployments;
     }
     subscribeToStatus(id, listener, errorListener) {
         listener(new MessageEvent('message', { data: 'running' }));
@@ -105,12 +113,9 @@ class FlowDeploymentMockService extends data_mock_service_1.DataMockService {
     }
     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');
-            }
+            if (prop !== 'assetId')
+                throw new Error('not implemented');
+            return { id: (await this.api.assets.getOne(properties[prop])).id, resourceType: 'asset' };
         }));
     }
 }

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

@@ -1,7 +1,7 @@
+import { Paginated } from '../data.interface';
 import { DataMockService } from './data.mock.service';
 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 revisions;
     constructor(functions: FlowFunctionDto[], revisions: FlowFunctionRevision[]);

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

@@ -1,8 +1,8 @@
 "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");
+const data_mock_service_1 = require("./data.mock.service");
 class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
     constructor(functions, revisions) {
         super();
@@ -20,8 +20,8 @@ class FlowFunctionsMockService extends data_mock_service_1.DataMockService {
         this.revisions
             .filter((revision) => revision.originalId === fqn)
             .forEach((revision) => {
-            const index = this.revisions.indexOf(revision);
-            this.revisions.splice(index, 1);
+            const index1 = this.revisions.indexOf(revision);
+            this.revisions.splice(index1, 1);
         });
         return Promise.resolve(undefined);
     }

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

@@ -1,14 +1,20 @@
-import { DataMockService } from './data.mock.service';
+import { Paginated, RequestParameter } from '../data.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 {
+import { APIBaseMock } from './api-base.mock';
+import { DataMockService } from './data.mock.service';
+import { TrashMockService } from './trash.mock.service';
+interface BaseService extends DataMockService<FlowDto>, TrashMockService<FlowDto> {
+}
+declare class BaseService extends APIBaseMock<FlowDto> {
+}
+export declare class FlowMockService extends BaseService implements FlowService {
     private diagrams;
     private revisions;
     constructor(flows: FlowDto[], diagrams: FlowDiagram[], revisions: FlowRevision[]);
+    deleteOne(id: string, force?: boolean): Promise<FlowDto>;
     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[]>;
@@ -18,3 +24,4 @@ export declare class FlowMockService extends DataMockService<FlowDto> implements
     rollback(id: string, revisionId: string): Promise<FlowDto>;
     deleteRevision(id: string, revisionId: string): Promise<any>;
 }
+export {};

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

@@ -1,21 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowMockService = void 0;
-const data_mock_service_1 = require("./data.mock.service");
+const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
-class FlowMockService extends data_mock_service_1.DataMockService {
+const ts_mixer_1 = require("ts-mixer");
+const api_base_mock_1 = require("./api-base.mock");
+const data_mock_service_1 = require("./data.mock.service");
+const trash_mock_service_1 = require("./trash.mock.service");
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class FlowMockService extends BaseService {
     constructor(flows, diagrams, revisions) {
-        super();
+        super(flows);
         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) {
+    deleteOne(id, force = false) {
+        const flow = this.data.find((v) => v.id === id);
+        if (!(flow === null || flow === void 0 ? void 0 : flow.deletedAt) && !force) {
+            flow.deletedAt = new Date().toISOString();
+            return Promise.resolve(flow);
+        }
         this.revisions
             .filter((revision) => revision.originalId === id)
             .forEach((revision) => {
@@ -24,6 +32,11 @@ class FlowMockService extends data_mock_service_1.DataMockService {
         });
         return super.deleteOne(id);
     }
+    addOne(dto) {
+        const id = (0, crypto_1.randomUUID)();
+        this.revisions.push(Object.assign(Object.assign({}, dto), { id, originalId: dto.id }));
+        return super.addOne(dto);
+    }
     async updateOne(id, dto) {
         await super.deleteOne(id);
         const flow = await this.addOne(dto);
@@ -33,7 +46,7 @@ class FlowMockService extends data_mock_service_1.DataMockService {
         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;
+        return revisions[revisions.length - 1].id === diagramId;
     }
     getDiagramRevisions(id) {
         return Promise.resolve(this.diagrams.filter((v) => v.flow === id));
@@ -42,7 +55,7 @@ class FlowMockService extends data_mock_service_1.DataMockService {
         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);
+        const flows = this.getItems(params, false);
         return {
             docs: flows.docs.map((v) => (Object.assign(Object.assign({}, v), { diagram: this.diagrams.find((v1) => v1.id === v.diagram) }))),
             total: 0,

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

@@ -1,6 +1,16 @@
 import { Secret } from '../secret.interface';
 import { SecretService } from '../secret.service';
+import { Paginated, RequestParameter } from '../data.interface';
+import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
-export declare class SecretMockService extends DataMockService<Secret> implements SecretService {
+import { TrashMockService } from './trash.mock.service';
+interface BaseService extends DataMockService<Secret>, TrashMockService<Secret> {
+}
+declare class BaseService extends APIBaseMock<Secret> {
+}
+export declare class SecretMockService extends BaseService implements SecretService {
     constructor(secrets: Secret[]);
+    deleteOne(contentId: string, force?: boolean): Promise<Secret>;
+    getMany(params?: RequestParameter): Promise<Paginated<Secret[]>>;
 }
+export {};

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

@@ -1,11 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecretMockService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
-class SecretMockService extends data_mock_service_1.DataMockService {
+const trash_mock_service_1 = require("./trash.mock.service");
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class SecretMockService extends BaseService {
     constructor(secrets) {
-        super();
-        this.data = secrets;
+        super(secrets);
+    }
+    deleteOne(contentId, force = false) {
+        const content = this.data.find((v) => v.id === contentId);
+        if (!(content === null || content === void 0 ? void 0 : content.deletedAt) && !force) {
+            content.deletedAt = new Date().toISOString();
+            return Promise.resolve(content);
+        }
+        return super.deleteOne(contentId);
+    }
+    getMany(params) {
+        const page = this.getItems(params, false);
+        return Promise.resolve(page);
     }
 }
 exports.SecretMockService = SecretMockService;

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

@@ -1,7 +1,17 @@
+import { Paginated, RequestParameter } from '../data.interface';
 import { Task } from '../task.interface';
 import { TaskService } from '../task.service';
+import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
-export declare class TaskMockService extends DataMockService<Task> implements TaskService {
+import { TrashMockService } from './trash.mock.service';
+interface BaseService extends DataMockService<Task>, TrashMockService<Task> {
+}
+declare class BaseService extends APIBaseMock<Task> {
+}
+export declare class TaskMockService extends BaseService implements TaskService {
     constructor(tasks: Task[]);
     createTaskAttachedToAsset(dto: any): Promise<Task>;
+    deleteOne(taskId: string, force?: boolean): Promise<Task>;
+    getMany(params?: RequestParameter): Promise<Paginated<Task[]>>;
 }
+export {};

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

@@ -1,15 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskMockService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
-class TaskMockService extends data_mock_service_1.DataMockService {
+const trash_mock_service_1 = require("./trash.mock.service");
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class TaskMockService extends BaseService {
     constructor(tasks) {
-        super();
-        this.data = tasks;
+        super(tasks);
     }
     async createTaskAttachedToAsset(dto) {
         this.data.push(dto);
         return Promise.resolve(dto);
     }
+    deleteOne(taskId, force = false) {
+        const task = this.data.find((v) => v.id === taskId);
+        if (!(task === null || task === void 0 ? void 0 : task.deletedAt) && !force) {
+            task.deletedAt = new Date().toISOString();
+            return Promise.resolve(task);
+        }
+        return super.deleteOne(taskId);
+    }
+    getMany(params) {
+        const page = this.getItems(params, false);
+        return Promise.resolve(page);
+    }
 }
 exports.TaskMockService = TaskMockService;

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

@@ -1,11 +1,25 @@
-import { Paginated } from '../data.interface';
+import { Paginated, RequestParameter } from '../data.interface';
 import { TimeSeries, TimeSeriesValue, TS_GROUPS } from '../timeseries.interface';
 import { TimeSeriesService } from '../timeseries.service';
+import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
-export declare class TimeseriesMockService extends DataMockService<TimeSeries & {
+import { TrashMockService } from './trash.mock.service';
+interface BaseService extends DataMockService<TimeSeries & {
     data: TimeSeriesValue[];
-}> implements TimeSeriesService {
+}>, TrashMockService<TimeSeries & {
+    data: TimeSeriesValue[];
+}> {
+}
+declare class BaseService extends APIBaseMock<TimeSeries & {
+    data: TimeSeriesValue[];
+}> {
+}
+export declare class TimeseriesMockService extends BaseService implements TimeSeriesService {
     constructor(timeseries: TimeSeries[], timeseriesValues: TimeSeriesValue[][]);
+    deleteOne(tsmId: string, force?: boolean): Promise<TimeSeries>;
+    getMany(params?: RequestParameter): Promise<Paginated<(TimeSeries & {
+        data: TimeSeriesValue[];
+    })[]>>;
     addAssetTimeSeriesValues(assetId: string, name: string, readPermissions: string[], readWritePermissions: string[], values: {
         [p: string]: any;
     }): Promise<TimeSeries>;
@@ -17,3 +31,4 @@ export declare class TimeseriesMockService extends DataMockService<TimeSeries &
     getValues(id: string, from: number, limit?: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
     getValuesOfPeriod(id: string, from: number, to: number, group?: TS_GROUPS): Promise<TimeSeriesValue[]>;
 }
+export {};

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

@@ -1,11 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TimeseriesMockService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
-class TimeseriesMockService extends data_mock_service_1.DataMockService {
+const trash_mock_service_1 = require("./trash.mock.service");
+let BaseService = class BaseService extends api_base_mock_1.APIBaseMock {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService)
+], BaseService);
+class TimeseriesMockService extends BaseService {
     constructor(timeseries, timeseriesValues) {
-        super();
-        this.data = timeseries.map((value, index) => (Object.assign(Object.assign({}, value), { data: timeseriesValues[index] })));
+        const data = timeseries.map((value, index) => (Object.assign(Object.assign({}, value), { data: timeseriesValues[index] })));
+        super(data);
+    }
+    deleteOne(tsmId, force = false) {
+        const tsm = this.data.find((v) => v.id === tsmId);
+        if (!(tsm === null || tsm === void 0 ? void 0 : tsm.deletedAt) && !force) {
+            tsm.deletedAt = new Date().toISOString();
+            return Promise.resolve(tsm);
+        }
+        return super.deleteOne(tsmId);
+    }
+    getMany(params) {
+        const page = this.getItems(params, false);
+        return Promise.resolve(page);
     }
     addAssetTimeSeriesValues(assetId, name, readPermissions, readWritePermissions, values) {
         const ts = this.data.find((v) => v.assetRef === assetId);
@@ -31,7 +52,6 @@ class TimeseriesMockService extends data_mock_service_1.DataMockService {
     async addValue(id, value) {
         const ts = await this.getOne(id, {});
         ts.data.push({ timestamp: new Date().valueOf(), value });
-        return;
     }
     getManyByAsset(assetId, names) {
         const page = { docs: [], limit: 10, total: 0 };

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

@@ -0,0 +1,18 @@
+import { TrashService } from '../trash.service';
+import { Paginated, RequestParameter } from '../data.interface';
+import { APIBaseMock } from './api-base.mock';
+export declare class TrashMockService<T extends {
+    id?: string;
+}> extends TrashService<T> implements APIBaseMock<T> {
+    data: T[];
+    protected deleteOnecbf: any;
+    constructor();
+    trashRestoreAll(): Promise<T[]>;
+    trashRestoreOne(id: string): Promise<T>;
+    emptyTrash(offset: number): Promise<{
+        acknowledged: boolean;
+        deletedCount: number;
+    }>;
+    getTrash(params?: RequestParameter): Promise<Paginated<T[]>>;
+    protected getItems(params: RequestParameter, deleted?: boolean): Paginated<T[]>;
+}

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrashMockService = void 0;
+const trash_service_1 = require("../trash.service");
+class TrashMockService extends trash_service_1.TrashService {
+    constructor() {
+        super(null, null);
+        this.data = [];
+    }
+    trashRestoreAll() {
+        const deleted = this.data.filter((v) => v['deletedAt']);
+        for (const asset of deleted) {
+            delete asset['deletedAt'];
+        }
+        return Promise.resolve(deleted);
+    }
+    trashRestoreOne(id) {
+        const deleted = this.data.find((v) => v['id'] === id);
+        delete deleted['deletedAt'];
+        return Promise.resolve(deleted);
+    }
+    async emptyTrash(offset) {
+        const dateOffsSeconds = Math.round(new Date().getTime() / 1000) - offset;
+        const date = new Date(dateOffsSeconds * 1000);
+        const trashIds = this.data.filter((v) => new Date(v['deletedAt']) < date).map((v) => v.id);
+        this.data = this.data.filter((item) => !trashIds.includes(item.id));
+        return Promise.resolve({ acknowledged: true, deletedCount: trashIds.length });
+    }
+    getTrash(params) {
+        const page = this.getItems(params, true);
+        return Promise.resolve(page);
+    }
+    getItems(params, deleted = false) {
+        const data = this.data.filter((item) => !!item['deletedAt'] === deleted);
+        const page = {
+            docs: data,
+            limit: params && params.limit ? params.limit : Number.MAX_SAFE_INTEGER,
+            total: data.length,
+        };
+        return page;
+    }
+}
+exports.TrashMockService = TrashMockService;

package/dist/resource.interface.d.ts

@@ -14,6 +14,6 @@ export interface Resource {
     refs?: ResourceReference[];
     createdAt?: string | Date;
     updatedAt?: string | Date;
-    deleteddAt?: string | Date;
+    deletedAt?: string | Date;
     revision?: string;
 }

package/dist/secret.interface.d.ts

@@ -4,4 +4,5 @@ export interface Secret {
     key: string;
     readPermissions: string[];
     readWritePermissions: string[];
+    deletedAt?: string;
 }

package/dist/secret.service.d.ts

@@ -1,6 +1,13 @@
+import { APIBase } from './api-base';
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
 import { Secret } from './secret.interface';
-export declare class SecretService extends DataService<Secret> {
+import { TrashService } from './trash.service';
+interface BaseService extends DataService<Secret>, TrashService<Secret> {
+}
+declare class BaseService extends APIBase {
+}
+export declare class SecretService extends BaseService {
     constructor(httpClient: HttpClient);
 }
+export {};

package/dist/secret.service.js

@@ -1,8 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecretService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const api_base_1 = require("./api-base");
 const data_service_1 = require("./data.service");
-class SecretService extends data_service_1.DataService {
+const trash_service_1 = require("./trash.service");
+let BaseService = class BaseService extends api_base_1.APIBase {
+};
+BaseService = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService)
+], BaseService);
+class SecretService extends BaseService {
     constructor(httpClient) {
         super(httpClient, '/secrets');
     }

package/dist/task.interface.d.ts

@@ -19,4 +19,5 @@ export interface Task {
     weight?: number;
     createdAt?: string;
     updatedAt?: string;
+    deletedAt?: string;
 }