@hahnpro/hpc-api 3.2.1 → 3.3.0

package/dist/api-base.d.ts

@@ -0,0 +1,6 @@
+import { HttpClient } from './http.service';
+export declare class APIBase {
+    protected readonly httpClient: HttpClient;
+    protected readonly basePath: string;
+    constructor(httpClient: HttpClient, basePath: string);
+}

package/dist/api-base.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIBase = void 0;
+class APIBase {
+    constructor(httpClient, basePath) {
+        this.httpClient = httpClient;
+        this.basePath = basePath;
+    }
+}
+exports.APIBase = APIBase;

package/dist/asset.interface.d.ts

@@ -15,6 +15,7 @@ export interface AssetType {
     updatedAt?: string;
     author?: string;
     revision?: number;
+    deletedAt?: string;
 }
 export declare type AssetTypeRevision = AssetType & {
     originalId: string;

package/dist/asset.service.d.ts

@@ -1,17 +1,17 @@
 import FormData from 'form-data';
+import { APIBase } from './api-base';
 import { Asset, AssetRevision } from './asset.interface';
 import { Paginated, RequestParameter } from './data.interface';
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
-export declare class AssetService extends DataService<Asset> {
+import { TrashService } from './trash.service';
+interface MixedClass extends DataService<Asset>, TrashService<Asset> {
+}
+declare class MixedClass extends APIBase {
+    constructor(httpClient: HttpClient, basePath: string);
+}
+export declare class AssetService extends MixedClass {
     constructor(httpClient: HttpClient);
-    paperBinRestoreAll(): Promise<Asset[]>;
-    paperBinRestoreOne(id: string): Promise<Asset>;
-    emptyTrash(offset: number): Promise<{
-        acknowledged: boolean;
-        deletedCount: number;
-    }>;
-    getPaperBin(params?: RequestParameter): Promise<Paginated<Asset[]>>;
     deleteOne(id: string, force?: boolean): Promise<any>;
     addAttachment: (id: string, form: FormData) => Promise<Asset>;
     getChildren(assetId: string, params?: RequestParameter): Promise<Paginated<Asset[]>>;
@@ -19,3 +19,4 @@ export declare class AssetService extends DataService<Asset> {
     rollback(assetId: string, revisionId: string): Promise<Asset>;
     deleteRevision(assetId: string, revisionId: string): Promise<any>;
 }
+export {};

package/dist/asset.service.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetService = 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 AssetService extends data_service_1.DataService {
+const http_service_1 = require("./http.service");
+const trash_service_1 = require("./trash.service");
+let MixedClass = class MixedClass extends api_base_1.APIBase {
+    constructor(httpClient, basePath) {
+        super(httpClient, basePath);
+    }
+};
+MixedClass = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
+    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
+], MixedClass);
+class AssetService extends MixedClass {
     constructor(httpClient) {
         super(httpClient, '/assets');
         this.addAttachment = (id, form) => {
@@ -14,20 +28,6 @@ class AssetService extends data_service_1.DataService {
             });
         };
     }
-    paperBinRestoreAll() {
-        return this.httpClient.put(`${this.basePath}/paperbin/restore`, {});
-    }
-    paperBinRestoreOne(id) {
-        return this.httpClient.put(`${this.basePath}/paperbin/restore/${id}`, {});
-    }
-    emptyTrash(offset) {
-        return this.httpClient.delete(`${this.basePath}/paperbin/clean`, { params: { offset } });
-    }
-    getPaperBin(params = {}) {
-        params.limit = params.limit || 0;
-        params.page = params.page || 1;
-        return this.httpClient.get(`${this.basePath}/paperbin`, { params });
-    }
     deleteOne(id, force = false) {
         return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force } });
     }

package/dist/assettypes.service.d.ts

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

package/dist/assettypes.service.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetTypesService = 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 AssetTypesService extends data_service_1.DataService {
+const http_service_1 = require("./http.service");
+const trash_service_1 = require("./trash.service");
+let MixedClass = class MixedClass extends api_base_1.APIBase {
+    constructor(httpClient, basePath) {
+        super(httpClient, basePath);
+    }
+};
+MixedClass = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
+    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
+], MixedClass);
+class AssetTypesService extends MixedClass {
     constructor(httpClient) {
         super(httpClient, '/assettypes');
     }

package/dist/content.interface.d.ts

@@ -12,6 +12,7 @@ export interface Content {
     files?: Storage[];
     createdAt?: string;
     updatedAt?: string;
+    deletedAt?: string;
 }
 export declare enum ReturnType {
     TEXT = 0,

package/dist/content.service.d.ts

@@ -1,11 +1,18 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import FormData from 'form-data';
+import { Readable } from 'stream';
+import { APIBase } from './api-base';
 import { Content, ReturnType } from './content.interface';
 import { DataService } from './data.service';
 import { HttpClient } from './http.service';
-import { Readable } from 'stream';
-export declare class ContentService extends DataService<Content> {
+import { TrashService } from './trash.service';
+interface MixedClass extends DataService<Content>, TrashService<Content> {
+}
+declare class MixedClass extends APIBase {
+    constructor(httpClient: HttpClient, basePath: string);
+}
+export declare class ContentService extends MixedClass {
     constructor(httpClient: HttpClient);
     upload: (form: FormData) => Promise<Content>;
     download(id: string, raw?: boolean): Promise<Blob | ArrayBuffer>;
@@ -16,3 +23,4 @@ export declare class ContentService extends DataService<Content> {
     download(id: string, returnType: ReturnType.ARRAYBUFFER): Promise<ArrayBuffer>;
     download(id: string, returnType: ReturnType.NODESTREAM): Promise<Readable>;
 }
+export {};

package/dist/content.service.js

@@ -1,9 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const api_base_1 = require("./api-base");
 const content_interface_1 = require("./content.interface");
 const data_service_1 = require("./data.service");
-class ContentService extends data_service_1.DataService {
+const http_service_1 = require("./http.service");
+const trash_service_1 = require("./trash.service");
+let MixedClass = class MixedClass extends api_base_1.APIBase {
+    constructor(httpClient, basePath) {
+        super(httpClient, basePath);
+    }
+};
+MixedClass = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
+    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
+], MixedClass);
+class ContentService extends MixedClass {
     constructor(httpClient) {
         super(httpClient, '/contents');
         this.upload = (form) => {

package/dist/data.service.d.ts

@@ -1,15 +1,14 @@
+import { APIBase } from './api-base';
 import { DataInterface, Filter, Paginated, RequestParameter } from './data.interface';
 import { HttpClient } from './http.service';
-export declare class DataService<T> implements DataInterface<T> {
-    protected readonly httpClient: HttpClient;
-    protected readonly basePath: any;
-    constructor(httpClient: HttpClient, basePath: any);
+export declare class DataService<T> extends APIBase implements DataInterface<T> {
+    constructor(httpClient: HttpClient, basePath: string);
     addOne(dto: any): Promise<T>;
     addMany(dto: any[]): Promise<T[]>;
     getOne(id: string, options?: any): Promise<T>;
     getMany(params?: RequestParameter): Promise<Paginated<T[]>>;
     getManyFiltered(filter: Filter, params?: RequestParameter): Promise<Paginated<T[]>>;
     updateOne(id: string, dto: any): Promise<T>;
-    deleteOne(id: string): Promise<any>;
-    protected getFilterString(filter: Filter): string;
+    deleteOne(id: string, force?: boolean): Promise<any>;
+    private getFilterString;
 }

package/dist/data.service.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataService = void 0;
-class DataService {
+const api_base_1 = require("./api-base");
+class DataService extends api_base_1.APIBase {
     constructor(httpClient, basePath) {
-        this.httpClient = httpClient;
-        this.basePath = basePath;
+        super(httpClient, basePath);
     }
     addOne(dto) {
         return this.httpClient.post(this.basePath, dto);
@@ -28,8 +28,8 @@ class DataService {
     updateOne(id, dto) {
         return this.httpClient.put(`${this.basePath}/${id}`, dto);
     }
-    deleteOne(id) {
-        return this.httpClient.delete(`${this.basePath}/${id}`);
+    deleteOne(id, force = false) {
+        return this.httpClient.delete(`${this.basePath}/${id}`, { params: { force } });
     }
     getFilterString(filter) {
         const { parent, tags, type } = filter;

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

@@ -1,8 +1,15 @@
+import { APIBase } from './api-base';
 import { DataService } from './data.service';
 import { FlowDeployment, FlowDeploymentMetrics, FlowDeploymentStatistic, FlowLog } from './flow-deployment.interface';
 import { HttpClient } from './http.service';
 import { ResourceReference } from './resource.interface';
-export declare class FlowDeploymentService extends DataService<FlowDeployment> {
+import { TrashService } from './trash.service';
+interface MixedClass extends DataService<FlowDeployment>, TrashService<FlowDeployment> {
+}
+declare class MixedClass extends APIBase {
+    constructor(httpClient: HttpClient, basePath: string);
+}
+export declare class FlowDeploymentService extends MixedClass {
     constructor(httpClient: HttpClient);
     addMany(dto: any[]): Promise<FlowDeployment[]>;
     updateOne(id: string, dto: any, force?: boolean): Promise<FlowDeployment>;
@@ -24,3 +31,4 @@ export declare class FlowDeploymentService extends DataService<FlowDeployment> {
     subscribeToStatus(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
     subscribeToLogs(id: string, listener: (event: MessageEvent<any>) => void, errorListener?: (event: MessageEvent) => void): Promise<string>;
 }
+export {};

package/dist/flow-deployment.service.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowDeploymentService = 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 FlowDeploymentService extends data_service_1.DataService {
+const http_service_1 = require("./http.service");
+const trash_service_1 = require("./trash.service");
+let MixedClass = class MixedClass extends api_base_1.APIBase {
+    constructor(httpClient, basePath) {
+        super(httpClient, basePath);
+    }
+};
+MixedClass = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
+    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
+], MixedClass);
+class FlowDeploymentService extends MixedClass {
     constructor(httpClient) {
         super(httpClient, '/flow/deployments');
     }

package/dist/flow.interface.d.ts

@@ -24,5 +24,5 @@ export interface FlowDiagram {
     author: string;
     createdAt?: Date | string;
     updatedAt?: Date | string;
-    deleteddAt?: Date | string;
+    deletedAt?: Date | string;
 }

package/dist/flow.service.d.ts

@@ -1,9 +1,16 @@
+import { APIBase } from './api-base';
+import { Paginated, RequestParameter } from './data.interface';
 import { DataService } from './data.service';
 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> {
+import { HttpClient } from './http.service';
+import { TrashService } from './trash.service';
+interface MixedClass extends DataService<FlowDto>, TrashService<FlowDto> {
+}
+declare class MixedClass extends APIBase {
+    constructor(httpClient: HttpClient, basePath: string);
+}
+export declare class FlowService extends MixedClass {
     constructor(httpClient: HttpClient);
     addMany(dto: any[]): Promise<FlowDto[]>;
     getMany(params?: RequestParameter): Promise<Paginated<FlowDto[]>>;
@@ -15,3 +22,4 @@ export declare class FlowService extends DataService<FlowDto> {
     rollback(id: string, revisionId: string): Promise<FlowDto>;
     deleteRevision(id: string, revisionId: string): Promise<any>;
 }
+export {};

package/dist/flow.service.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlowService = 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 FlowService extends data_service_1.DataService {
+const http_service_1 = require("./http.service");
+const trash_service_1 = require("./trash.service");
+let MixedClass = class MixedClass extends api_base_1.APIBase {
+    constructor(httpClient, basePath) {
+        super(httpClient, basePath);
+    }
+};
+MixedClass = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_service_1.DataService, trash_service_1.TrashService),
+    tslib_1.__metadata("design:paramtypes", [http_service_1.HttpClient, String])
+], MixedClass);
+class FlowService extends MixedClass {
     constructor(httpClient) {
         super(httpClient, '/flows');
     }

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

@@ -0,0 +1,5 @@
+import { APIBase } from '../api-base';
+export declare class APIBaseMock<T> extends APIBase {
+    data: T[];
+    constructor(data?: T[]);
+}

package/dist/mock/api-base.mock.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIBaseMock = void 0;
+const api_base_1 = require("../api-base");
+class APIBaseMock extends api_base_1.APIBase {
+    constructor(data = []) {
+        super(null, null);
+        this.data = data;
+    }
+}
+exports.APIBaseMock = APIBaseMock;

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

@@ -3,18 +3,18 @@ import { Asset, AssetRevision } from '../asset.interface';
 import { AssetService } from '../asset.service';
 import { Paginated, RequestParameter } from '../data.interface';
 import { MockAPI } from './api.mock';
+import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
-export declare class AssetMockService extends DataMockService<Asset> implements AssetService {
+import { TrashMockService } from './trash.mock.service';
+interface MixedClass extends DataMockService<Asset>, TrashMockService<Asset> {
+}
+declare class MixedClass extends APIBaseMock<Asset> {
+    constructor(data: Asset[]);
+}
+export declare class AssetMockService extends MixedClass implements AssetService {
     private api;
     private revisions;
     constructor(api: MockAPI, assets: Asset[], revisions: AssetRevision[]);
-    paperBinRestoreAll(): Promise<Asset[]>;
-    paperBinRestoreOne(id: string): Promise<Asset>;
-    emptyTrash(offset: number): Promise<{
-        acknowledged: boolean;
-        deletedCount: number;
-    }>;
-    getPaperBin(params?: RequestParameter): Promise<Paginated<Asset[]>>;
     private getAssets;
     addOne(dto: Asset): Promise<Asset>;
     deleteOne(assetId: string, force?: boolean): Promise<Asset>;
@@ -26,3 +26,4 @@ export declare class AssetMockService extends DataMockService<Asset> implements
     rollback(assetId: string, revisionId: string): Promise<Asset>;
     deleteRevision(assetId: string, revisionId: string): Promise<any>;
 }
+export {};

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

@@ -1,36 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AssetMockService = void 0;
+const tslib_1 = require("tslib");
+const ts_mixer_1 = require("ts-mixer");
+const api_base_mock_1 = require("./api-base.mock");
 const data_mock_service_1 = require("./data.mock.service");
-class AssetMockService extends data_mock_service_1.DataMockService {
+const trash_mock_service_1 = require("./trash.mock.service");
+let MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
+    constructor(data) {
+        super(data);
+    }
+};
+MixedClass = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
+    tslib_1.__metadata("design:paramtypes", [Array])
+], MixedClass);
+class AssetMockService extends MixedClass {
     constructor(api, assets, revisions) {
-        super();
+        super(assets);
         this.api = api;
         this.revisions = revisions;
-        this.data = assets;
-    }
-    paperBinRestoreAll() {
-        const deleted = this.data.filter((v) => v.deletedAt);
-        for (const asset of deleted) {
-            delete asset.deletedAt;
-        }
-        return Promise.resolve(deleted);
-    }
-    paperBinRestoreOne(id) {
-        const deleted = this.data.find((v) => v.id === id);
-        delete deleted.deletedAt;
-        return Promise.resolve(deleted);
-    }
-    emptyTrash(offset) {
-        const dateOffsSeconds = Math.round(new Date().getTime() / 1000) - offset;
-        const date = new Date(dateOffsSeconds * 1000);
-        const trash = this.data.filter((v) => new Date(v.deletedAt) < date);
-        trash.map((v) => this.deleteOne(v.id));
-        return Promise.resolve({ acknowledged: true, deletedCount: trash.length });
-    }
-    getPaperBin(params) {
-        const page = this.getAssets(params, true);
-        return Promise.resolve(page);
     }
     getAssets(params, deleted = false) {
         const data = this.data.filter((asset) => !!asset.deletedAt === deleted);

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

@@ -1,14 +1,23 @@
 import { AssetType, AssetTypeRevision } from '../asset.interface';
 import { AssetTypesService } from '../assettypes.service';
+import { Paginated, RequestParameter } from '../data.interface';
+import { APIBaseMock } from './api-base.mock';
 import { DataMockService } from './data.mock.service';
-import { Paginated } from '../data.interface';
-export declare class AssetTypesMockService extends DataMockService<AssetType> implements AssetTypesService {
+import { TrashMockService } from './trash.mock.service';
+interface MixedClass extends DataMockService<AssetType>, TrashMockService<AssetType> {
+}
+declare class MixedClass extends APIBaseMock<AssetType> {
+    constructor(data: AssetType[]);
+}
+export declare class AssetTypesMockService extends MixedClass implements AssetTypesService {
     private revisions;
     constructor(assetTypes: AssetType[], revisions: AssetTypeRevision[]);
+    getMany(params?: RequestParameter): Promise<Paginated<AssetType[]>>;
     addOne(dto: AssetType): Promise<AssetType>;
-    deleteOne(id: string): Promise<any>;
+    deleteOne(id: string, force?: boolean): 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>;
 }
+export {};

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

@@ -1,20 +1,41 @@
 "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 MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
+    constructor(data) {
+        super(data);
+    }
+};
+MixedClass = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
+    tslib_1.__metadata("design:paramtypes", [Array])
+], MixedClass);
+class AssetTypesMockService extends MixedClass {
     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,16 @@ 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 MixedClass extends DataMockService<Content>, TrashMockService<Content> {
+}
+declare class MixedClass extends APIBaseMock<Content> {
+    constructor(data: Content[]);
+}
+export declare class ContentMockService extends MixedClass implements ContentService {
     private contentData;
     constructor(contents: Content[], contentData: any[]);
     download(id: string, raw?: boolean): Promise<Blob | ArrayBuffer>;
@@ -15,5 +23,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,26 @@
 "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 MixedClass = class MixedClass extends api_base_mock_1.APIBaseMock {
+    constructor(data) {
+        super(data);
+    }
+};
+MixedClass = tslib_1.__decorate([
+    (0, ts_mixer_1.mix)(data_mock_service_1.DataMockService, trash_mock_service_1.TrashMockService),
+    tslib_1.__metadata("design:paramtypes", [Array])
+], MixedClass);
+class ContentMockService extends MixedClass {
     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 +69,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>;