@rockster/core 0.0.1

package/storage/services/routes.service.js

@@ -0,0 +1,384 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutesService = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const http_1 = require("../../http");
+const security_1 = require("../../security");
+const common_1 = require("@rockster/common");
+const busboy_1 = __importDefault(require("busboy"));
+const interfaces_1 = require("../interfaces");
+const typeorm_1 = require("typeorm");
+const database_1 = require("../../database");
+const metadata_entity_1 = require("../entities/metadata.entity");
+const path_1 = require("path");
+const storage_entity_1 = require("../entities/storage.entity");
+const storage_service_1 = require("./storage.service");
+const env_1 = require("../env");
+const use_auth_1 = require("../../security/functions/use-auth");
+let RoutesService = class RoutesService {
+    constructor(httpController, storageService) {
+        this.httpController = httpController;
+        this.storageService = storageService;
+        this.storagePath = '/storage';
+        this.isAuthEnabled = false;
+    }
+    async active() {
+        this.isAuthEnabled = (0, security_1.isAuthEnabled)();
+        this.uploadFileRoute();
+        this.removeFileRoute();
+        this.readFileRoute();
+    }
+    readFileRoute() {
+        const handle = async (request, response) => {
+            try {
+                const fullPath = decodeURIComponent(request.path)
+                    .replace(`${this.storagePath}`, '');
+                const file = await this
+                    .getSearchFileQueryBuilder()
+                    .where(`metadata.path = '${fullPath}' AND metadata.type = 'file'`)
+                    .leftJoinAndMapOne('metadata.storage', storage_entity_1.Storage, 'storage', `metadata.storage_id = storage.id`)
+                    .getOne();
+                if (!file) {
+                    return response.sendStatus(common_1.HttpStatus.notFound);
+                }
+                // START AUTHORIZATION
+                let session = null;
+                if (!env_1.env.options.public && (0, security_1.isAuthEnabled)() && !file.public) {
+                    session = await (0, use_auth_1.useAuth)().httpInterceptor(request);
+                }
+                if (env_1.env.interceptor?.onDownloadFile) {
+                    env_1.env.interceptor.onDownloadFile({
+                        file: file,
+                        request: request,
+                        session: session
+                    });
+                }
+                // END AUTHORIZATION
+                const downloader = this
+                    .storageService
+                    .getReadStream(`${file.id}${file.extension ? file.extension : ''}`, file.storage);
+                downloader.on('error', (err) => {
+                    core.options.onRequestError?.apply(this, [err]);
+                    response.writeHead(common_1.HttpStatus.internalServerError);
+                });
+                downloader.on('resume', () => {
+                    response.setHeader('Transfer-Encoding', 'chunked');
+                    response.setHeader('Content-Type', file.mimeType);
+                    response.setHeader('Date', file.date.toString());
+                });
+                downloader.on('data', (chunk) => {
+                    response.write(chunk);
+                });
+                downloader.on('close', () => {
+                    response.end();
+                });
+            }
+            catch (error) {
+                const code = error.httpCode || common_1.HttpStatus.internalServerError;
+                response.status(code).json(code === common_1.HttpStatus.internalServerError ? null : error);
+                core.options?.onRequestError?.apply(this, [error]);
+            }
+        };
+        this.httpController.addRoute(common_1.HttpMethod.get, `${this.storagePath}*`, handle);
+    }
+    removeFileRoute() {
+        const handle = async (request, response) => {
+            try {
+                // START AUTHORIZATION
+                let session = null;
+                if (!env_1.env.options.public && (0, security_1.isAuthEnabled)()) {
+                    session = await (0, use_auth_1.useAuth)().httpInterceptor(request);
+                }
+                // END AUTHORIZATION
+                const folderPath = decodeURIComponent(request.path)
+                    .replace(`${this.storagePath}`, '');
+                const filesParam = request.query.files;
+                if (!filesParam) {
+                    return response.status(common_1.HttpStatus.badRequest).json({
+                        message: `Please, send the files to exclude: queryParam: files=<file1>,<file2>`
+                    });
+                }
+                const files = filesParam.split(',');
+                const history = {};
+                for (const fileName of files) {
+                    const file = await this
+                        .getSearchFileQueryBuilder()
+                        .where(`"metadata"."path" = '${folderPath}/${fileName}' AND "metadata"."type" = 'file'`)
+                        .leftJoinAndMapOne('metadata.storage', storage_entity_1.Storage, 'storage', `metadata.storage_id = storage.id`)
+                        .getOne();
+                    if (!file) {
+                        history[fileName] = common_1.HttpStatus.notFound;
+                        continue;
+                    }
+                    ;
+                    // START AUTHORIZATION
+                    if (env_1.env.interceptor?.onDownloadFile) {
+                        await env_1.env.interceptor.onExcludeFile({
+                            file: file,
+                            request: request,
+                            session: session
+                        });
+                    }
+                    // END AUTHORIZATION
+                    await this
+                        .repository
+                        .delete(null, { id: file.id });
+                    await this
+                        .storageService
+                        .deleteFile(`${file.id}${file.extension}`, file.storage);
+                    history[fileName] = common_1.HttpStatus.ok;
+                }
+                response.status(common_1.HttpStatus.ok).json(history);
+            }
+            catch (error) {
+                const code = error.httpCode || common_1.HttpStatus.internalServerError;
+                response.status(code).json(code === common_1.HttpStatus.internalServerError ? null : error);
+                core.options?.onRequestError?.apply(this, [error]);
+            }
+        };
+        this.httpController.addRoute(common_1.HttpMethod.delete, `${this.storagePath}*`, handle);
+    }
+    waitForPropagation(callback) {
+        const oneSecond = 1000;
+        setTimeout(callback, oneSecond);
+    }
+    uploadFileRoute() {
+        const handle = async (request, response) => {
+            try {
+                // START AUTHORIZATION
+                let session = null;
+                if (!env_1.env.options.public && (0, security_1.isAuthEnabled)()) {
+                    session = await (0, use_auth_1.useAuth)().httpInterceptor(request);
+                }
+                // END AUTHORIZATION
+                if (!request.headers["content-type"]?.startsWith('multipart/form-data')) {
+                    return response
+                        .status(common_1.HttpStatus.badRequest)
+                        .json(new common_1.BadRequestError({
+                        message: 'Invalid content-type'
+                    }));
+                }
+                const fullPath = request.path;
+                const files = [];
+                const stream = (0, busboy_1.default)({ headers: request.headers });
+                const queryRunner = this
+                    .dataSource
+                    .createQueryRunner();
+                await queryRunner.startTransaction();
+                stream.on('file', async (override, reader, info) => {
+                    await this.tryExec(async () => {
+                        const canOverride = override === 'override'
+                            ? true
+                            : false;
+                        const { file, exists, storage } = await this
+                            .createFileIfNotExists(queryRunner, fullPath, info, parseInt(request.headers["content-length"]), request, session, canOverride);
+                        if (exists && !canOverride) {
+                            await queryRunner.rollbackTransaction();
+                            await queryRunner.release();
+                            return response
+                                .status(common_1.HttpStatus.badRequest)
+                                .json(new common_1.BadRequestError({
+                                message: `Duplicated file [${file.name}]`
+                            }));
+                        }
+                        const uploader = await this
+                            .storageService
+                            .getWriteStream(`${file.id}${file.extension || ''}`, storage);
+                        files.push(file);
+                        reader.on('data', (chunk) => {
+                            uploader.write(chunk);
+                        });
+                        reader.on('close', () => {
+                            uploader.end();
+                        });
+                    }, response, queryRunner);
+                });
+                stream.on('field', async (name) => {
+                    await queryRunner.rollbackTransaction();
+                    await queryRunner.release();
+                    response
+                        .status(common_1.HttpStatus.badGateway)
+                        .json(new common_1.BadRequestError({
+                        message: `Invalid item on formData [${name}]`
+                    }));
+                });
+                stream.on('close', async () => {
+                    if (!response.destroyed) {
+                        await queryRunner.commitTransaction();
+                        await queryRunner.release();
+                        this.waitForPropagation(() => {
+                            const body = { files: files };
+                            response.status(common_1.HttpStatus.created).json(body);
+                        });
+                    }
+                });
+                stream.on('error', async (error) => {
+                    await queryRunner.rollbackTransaction();
+                    await queryRunner.release();
+                    core.options.onRequestError?.apply(this, [error]);
+                    response.sendStatus(common_1.HttpStatus.internalServerError);
+                });
+                request.pipe(stream);
+            }
+            catch (error) {
+                const code = error.httpCode || common_1.HttpStatus.internalServerError;
+                response.status(code).json(code === common_1.HttpStatus.internalServerError ? null : error);
+                core.options?.onRequestError?.apply(this, [error]);
+            }
+        };
+        this.httpController.addRoute(common_1.HttpMethod.post, `${this.storagePath}*`, handle);
+    }
+    async tryExec(callback, response, queryRunner) {
+        try {
+            await callback();
+        }
+        catch (error) {
+            core.options?.onRequestError?.apply(this, [error]);
+            await queryRunner.rollbackTransaction();
+            if (!response.destroyed) {
+                response.sendStatus(common_1.HttpStatus.internalServerError);
+            }
+        }
+    }
+    async createFileIfNotExists(queryRunner, originalUrl, fileInfo, fileSize, request, session, canOverride) {
+        const directory = await this
+            .createDirectoryIfNotExists(queryRunner, originalUrl);
+        const storage = await this
+            .storageService
+            .getStorage(originalUrl);
+        const file = {
+            type: interfaces_1.MetadataType.file,
+            mimeType: fileInfo.mimeType,
+            name: fileInfo.filename,
+            extension: this.getExtension(fileInfo.filename),
+            encoding: fileInfo.encoding,
+            size: fileSize,
+            parent: directory.path,
+            path: (0, path_1.join)(directory.path, fileInfo.filename),
+            storageId: storage.id
+        };
+        if (env_1.env.interceptor?.onUploadFile) {
+            await env_1.env.interceptor.onUploadFile({
+                file: file,
+                request: request,
+                session: session
+            });
+        }
+        const queryBuilder = this
+            .getSearchFileQueryBuilder();
+        const exists = await queryBuilder
+            .where(`metadata.path = '${file.path}'`)
+            .getOne();
+        if (exists) {
+            const now = new Date();
+            if (canOverride) {
+                await this.repository.update({
+                    id: exists.id
+                }, {
+                    date: now,
+                    size: fileSize
+                });
+                await this
+                    .repository
+                    .createQueryBuilder()
+                    .update()
+                    .set({
+                    size: () => `"size" - ${exists.size} + ${fileSize}`
+                })
+                    .where(`"id" = '${directory.id}'`)
+                    .execute();
+                directory.size += -exists.size + fileSize;
+                exists.size = fileSize;
+                exists.date = now;
+            }
+            return {
+                file: exists,
+                exists: true,
+                storage
+            };
+        }
+        else {
+            await this
+                .repository
+                .createQueryBuilder()
+                .update()
+                .set({ size: () => `"size" + ${fileSize}` })
+                .where(`"id" = '${directory.id}'`)
+                .execute();
+            directory.size += fileSize;
+        }
+        await this
+            .repository
+            .save(file);
+        return {
+            file: file,
+            exists: false,
+            storage
+        };
+    }
+    getSearchFileQueryBuilder() {
+        return this
+            .repository
+            .createQueryBuilder('metadata');
+    }
+    async createDirectoryIfNotExists(queryRunner, url) {
+        const sanitized = url.replace(this.storagePath, '');
+        const paths = sanitized.split('/');
+        let current = null;
+        for (const path of paths) {
+            let normalized = `/${path}`;
+            let exists = await this
+                .repository
+                .findOneBy({
+                path: normalized,
+                type: interfaces_1.MetadataType.directory
+            });
+            if (!exists) {
+                exists = await this
+                    .repository
+                    .save({
+                    type: interfaces_1.MetadataType.directory,
+                    parent: current?.path,
+                    name: normalized,
+                    path: (0, path_1.join)(current?.path || '', normalized),
+                    size: 0
+                });
+            }
+            current = exists;
+        }
+        return current;
+    }
+    getExtension(fileName) {
+        const split = fileName.split('.');
+        if (split.length === 1) {
+            return undefined;
+        }
+        return `.${split.pop()}`;
+    }
+};
+exports.RoutesService = RoutesService;
+__decorate([
+    (0, database_1.InjectDataSource)(),
+    __metadata("design:type", typeorm_1.DataSource)
+], RoutesService.prototype, "dataSource", void 0);
+__decorate([
+    (0, database_1.InjectRepository)(() => metadata_entity_1.Metadata),
+    __metadata("design:type", Object)
+], RoutesService.prototype, "repository", void 0);
+exports.RoutesService = RoutesService = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [http_1.HttpController,
+        storage_service_1.StorageService])
+], RoutesService);

package/storage/services/storage.service.d.ts

@@ -0,0 +1,10 @@
+import { Storage } from "../entities/storage.entity";
+import { Repository } from "../../database";
+export declare class StorageService {
+    protected repository: Repository<Storage>;
+    getStorage(originalUrl: string): Promise<Storage>;
+    protected getGcpBucketFile(fileName: string, storage: Storage): import("@google-cloud/storage").File;
+    deleteFile(fileName: string, storage: Storage): Promise<[import("teeny-request").Response<any>]>;
+    getWriteStream(fileName: string, storage: Storage): Promise<import("stream").Writable>;
+    getReadStream(fileName: string, storage: Storage): import("stream").Readable;
+}

package/storage/services/storage.service.js

@@ -0,0 +1,92 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageService = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const env_1 = require("../env");
+const storage_entity_1 = require("../entities/storage.entity");
+const interfaces_1 = require("../interfaces");
+const storage_1 = require("@google-cloud/storage");
+const database_1 = require("../../database");
+let StorageService = class StorageService {
+    async getStorage(originalUrl) {
+        const [, , bucket] = originalUrl.split('/');
+        const storage = await this
+            .repository
+            .findOneBy({ id: bucket });
+        if (storage) {
+            return storage;
+        }
+        const current = env_1.env.settings;
+        if (!current) {
+            throw new Error('Storage settings is required!');
+        }
+        if (env_1.env.isCurrentStored) {
+            return env_1.env.settings;
+        }
+        ;
+        const stored = await this
+            .repository
+            .findOneBy({
+            id: env_1.env.settings.id
+        });
+        if (stored) {
+            return stored;
+        }
+        return this.repository.save(current);
+    }
+    getGcpBucketFile(fileName, storage) {
+        const gcpStorage = new storage_1.Storage({
+            credentials: storage.settings.credentials
+        });
+        const bucket = gcpStorage.bucket(storage.settings.bucket);
+        const file = bucket.file(fileName);
+        return file;
+    }
+    async deleteFile(fileName, storage) {
+        switch (storage.settings.type) {
+            case interfaces_1.StorageType.gcp:
+                const file = await this
+                    .getGcpBucketFile(fileName, storage);
+                return file.delete();
+            default:
+                return null;
+        }
+    }
+    async getWriteStream(fileName, storage) {
+        switch (storage.settings.type) {
+            case interfaces_1.StorageType.gcp:
+                const file = await this
+                    .getGcpBucketFile(fileName, storage);
+                return file.createWriteStream();
+            default:
+                return null;
+        }
+    }
+    getReadStream(fileName, storage) {
+        switch (storage.settings.type) {
+            case interfaces_1.StorageType.gcp:
+                const file = this
+                    .getGcpBucketFile(fileName, storage);
+                return file.createReadStream();
+            default:
+                return null;
+        }
+    }
+};
+exports.StorageService = StorageService;
+__decorate([
+    (0, database_1.InjectRepository)(() => storage_entity_1.Storage),
+    __metadata("design:type", Object)
+], StorageService.prototype, "repository", void 0);
+exports.StorageService = StorageService = __decorate([
+    (0, class_injector_1.Injectable)()
+], StorageService);

package/storage/storage.controller.d.ts

@@ -0,0 +1,10 @@
+import { Logger } from "@rockster/logger";
+import { DatabaseController } from "../database";
+import { RoutesService } from "./services/routes.service";
+export declare class StorageController {
+    protected databaseController: DatabaseController;
+    protected routesService: RoutesService;
+    protected logger: Logger;
+    constructor(databaseController: DatabaseController, routesService: RoutesService);
+    start(): Promise<void>;
+}

package/storage/storage.controller.js

@@ -0,0 +1,49 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageController = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const logger_1 = require("@rockster/logger");
+const database_1 = require("../database");
+const routes_service_1 = require("./services/routes.service");
+const metadata_entity_1 = require("./entities/metadata.entity");
+const storage_entity_1 = require("./entities/storage.entity");
+const env_1 = require("./env");
+let StorageController = class StorageController {
+    constructor(databaseController, routesService) {
+        this.databaseController = databaseController;
+        this.routesService = routesService;
+        this.logger = new logger_1.Logger('Storage');
+    }
+    async start() {
+        if (!core.options.storage) {
+            return;
+        }
+        env_1.env.options = core.options.storage;
+        if (env_1.env.options.interceptor) {
+            env_1.env.interceptor = await (0, class_injector_1.createInstance)(env_1.env.options.interceptor);
+        }
+        await this
+            .databaseController
+            .build([
+            metadata_entity_1.Metadata,
+            storage_entity_1.Storage
+        ]);
+        await this.routesService.active();
+        this.logger.log('Enabled');
+    }
+};
+exports.StorageController = StorageController;
+exports.StorageController = StorageController = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [database_1.DatabaseController,
+        routes_service_1.RoutesService])
+], StorageController);

package/tasks/constants.d.ts

@@ -0,0 +1,12 @@
+import { drizzle } from "drizzle-orm/node-postgres";
+import { NanoIdAlphabetType } from "../database/interfaces/enum/nano-id-alphabet-type";
+export declare const constants: {
+    database: ReturnType<typeof drizzle>;
+    fields: {
+        name: string;
+        type: any;
+    }[];
+    nanoIdOptions: {
+        customAlphabet: NanoIdAlphabetType;
+    };
+};

package/tasks/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constants = void 0;
+const nano_id_alphabet_type_1 = require("../database/interfaces/enum/nano-id-alphabet-type");
+const class_pipe_1 = require("@rockster/class-pipe");
+const task_message_1 = require("./models/task-message");
+exports.constants = {
+    database: null,
+    fields: (0, class_pipe_1.getExposeProperties)(task_message_1.TaskMessage)
+        .map((property) => {
+        return {
+            name: property.propertyKey,
+            type: property.isArray ? 'array'
+                : property.subtype ? 'object'
+                    : (property.type || 'object')
+        };
+    }),
+    nanoIdOptions: {
+        customAlphabet: nano_id_alphabet_type_1.NanoIdAlphabetType.lowerCaseLettersAndDigits
+    }
+};

package/tasks/decorators/index.d.ts

@@ -0,0 +1 @@
+export * from './task.decorator';

package/tasks/decorators/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./task.decorator"), exports);

package/tasks/decorators/task.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ITaskSettings } from "../interfaces/task-settings";
+export declare function Task<T>(settings: ITaskSettings<T>): (target: any) => void;

package/tasks/decorators/task.decorator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = Task;
+const class_injector_1 = require("@rockster/class-injector");
+const object_type_1 = require("../../common/interfaces/enum/object-type");
+const create_task_message_find_1 = require("../functions/create-task-message-find");
+const create_task_message_model_1 = require("../functions/create-task-message-model");
+const create_task_message_receptor_1 = require("../functions/create-task-message-receptor");
+const create_task_message_schema_1 = require("../functions/create-task-message-schema");
+const create_task_naming_1 = require("../functions/create-task-naming");
+const create_task_message_retry_1 = require("../functions/create-task-message-retry");
+function Task(settings) {
+    return (target) => {
+        const mergedSettings = {
+            attempts: 1,
+            public: false,
+            partitions: 1,
+            retentionDays: 7,
+            messagesLimit: 100,
+            ...settings
+        };
+        let nextPartitionId = 0;
+        const object = core.storage.createObject(target);
+        object.naming = (0, create_task_naming_1.createTaskNaming)(object.objectKey);
+        object.type = object_type_1.ObjectType.task;
+        object.settings = mergedSettings;
+        object.payload = settings.payload;
+        object.MessageSchema = (0, create_task_message_schema_1.createTaskMessageSchema)(object.naming);
+        object.MessageModel = (0, create_task_message_model_1.createTaskMessageModel)(object);
+        object.nextPartitionId = () => {
+            nextPartitionId++;
+            if (nextPartitionId > mergedSettings.partitions) {
+                nextPartitionId = 1;
+                return 1;
+            }
+            else {
+                return nextPartitionId;
+            }
+        };
+        (0, create_task_message_receptor_1.createTaskMessageReceptor)(object);
+        (0, create_task_message_find_1.createTaskMessageFind)(object);
+        (0, create_task_message_retry_1.createTaskMessageRetry)(object);
+        (0, class_injector_1.markInjectable)(target);
+    };
+}

package/tasks/functions/create-task-message-find.d.ts

@@ -0,0 +1,3 @@
+import { ObjectNote } from "@rockster/class-memory";
+import { ITaskObject } from "../interfaces/task-object";
+export declare function createTaskMessageFind(object: ObjectNote<ITaskObject>): void;