@rockster/core 0.0.1

package/tasks/interfaces/task-naming.d.ts

@@ -0,0 +1,11 @@
+export interface ITaskNaming {
+    table: string;
+    trigger: string;
+    channel: string;
+    postAction?: string;
+    findAction?: string;
+    retryAction?: string;
+    function: string;
+    model?: string;
+    partition?: (partitionId: number) => ITaskNaming;
+}

package/tasks/interfaces/task-naming.js

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

package/tasks/interfaces/task-object.d.ts

@@ -0,0 +1,17 @@
+import { GetTypeCallback, Instantiable } from "@rockster/common";
+import { ObjectType } from "../../common";
+import { IObject } from "../../core";
+import { ITaskSettings } from "./task-settings";
+import { PgTableWithColumns } from "drizzle-orm/pg-core";
+import { ITaskNaming } from "./task-naming";
+export interface ITaskObject extends IObject {
+    type: ObjectType.task;
+    settings: ITaskSettings<unknown>;
+    payload: GetTypeCallback;
+    MessageSchema: PgTableWithColumns<any>;
+    MessageModel: Instantiable;
+    naming: ITaskNaming;
+    nextPartitionId: () => number;
+    postIntercept?: boolean;
+    searchIntercept?: boolean;
+}

package/tasks/interfaces/task-object.js

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

package/tasks/interfaces/task-post-intercept.d.ts

@@ -0,0 +1,8 @@
+import { IRequestContext } from "../../core/interfaces/request-context";
+export type TaskOnPostArgs<T> = {
+    requestContext: IRequestContext;
+    messages: T[];
+};
+export interface ITaskPostIntercept<T> {
+    onPost(args: TaskOnPostArgs<T>): Promise<void>;
+}

package/tasks/interfaces/task-post-intercept.js

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

package/tasks/interfaces/task-runner.d.ts

@@ -0,0 +1,6 @@
+export type TaskOnRun<T> = {
+    message: T;
+};
+export interface ITaskRunner<T> {
+    onRun(args: TaskOnRun<T>): Promise<void>;
+}

package/tasks/interfaces/task-runner.js

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

package/tasks/interfaces/task-search-intercept.d.ts

@@ -0,0 +1,4 @@
+export type TaskOnSearch = {};
+export interface ITaskSearchIntercept {
+    onSearch(args: TaskOnSearch): Promise<void>;
+}

package/tasks/interfaces/task-search-intercept.js

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

package/tasks/interfaces/task-settings.d.ts

@@ -0,0 +1,15 @@
+import { GetTypeCallback } from "@rockster/common";
+export interface ITaskSettings<T> {
+    /**Executor for any message */
+    payload: GetTypeCallback;
+    /**Public action: false */
+    public?: boolean;
+    /**Default: 1 */
+    attempts?: number;
+    /**Default: 1 */
+    partitions?: number;
+    /**Default: 7 */
+    retentionDays?: number;
+    /**limit: 100. Indicates how many messages the runner will recieve to proccess*/
+    messagesLimit?: number;
+}

package/tasks/interfaces/task-settings.js

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

package/tasks/models/task-error.d.ts

@@ -0,0 +1,8 @@
+import { ITaskError } from "@rockster/common/tasks";
+export declare class TaskError extends Error implements ITaskError {
+    constructor(message: string, context?: string);
+    message: string;
+    context?: string;
+    stack?: string;
+    infos?: string;
+}

package/tasks/models/task-error.js

@@ -0,0 +1,40 @@
+"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.TaskError = void 0;
+const class_pipe_1 = require("@rockster/class-pipe");
+class TaskError extends Error {
+    constructor(message, context) {
+        super(message);
+        this.context = context;
+    }
+}
+exports.TaskError = TaskError;
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsString)(),
+    __metadata("design:type", String)
+], TaskError.prototype, "message", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsString)(),
+    __metadata("design:type", String)
+], TaskError.prototype, "context", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsString)(),
+    __metadata("design:type", String)
+], TaskError.prototype, "stack", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsString)(),
+    __metadata("design:type", String)
+], TaskError.prototype, "infos", void 0);

package/tasks/models/task-message-find.d.ts

@@ -0,0 +1,3 @@
+export declare class TaskMessageFind {
+    search?: string;
+}

package/tasks/models/task-message-find.js

@@ -0,0 +1,21 @@
+"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.TaskMessageFind = void 0;
+const class_pipe_1 = require("@rockster/class-pipe");
+class TaskMessageFind {
+}
+exports.TaskMessageFind = TaskMessageFind;
+__decorate([
+    (0, class_pipe_1.IsString)(),
+    (0, class_pipe_1.IsOptional)(),
+    __metadata("design:type", String)
+], TaskMessageFind.prototype, "search", void 0);

package/tasks/models/task-message.d.ts

@@ -0,0 +1,13 @@
+import { ITaskMessage, TaskMessageStatus, ITaskError } from '@rockster/common/tasks';
+import { TaskError } from './task-error';
+export declare abstract class TaskMessage<T> implements ITaskMessage<T> {
+    id?: string;
+    status?: TaskMessageStatus;
+    createdAt?: Date;
+    lastModifiedAt?: Date;
+    attempts?: number;
+    internalError?: TaskError;
+    error?: ITaskError;
+    payload: T;
+    partitionId: number;
+}

package/tasks/models/task-message.js

@@ -0,0 +1,57 @@
+"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.TaskMessage = void 0;
+const tasks_1 = require("@rockster/common/tasks");
+const class_pipe_1 = require("@rockster/class-pipe");
+const task_error_1 = require("./task-error");
+class TaskMessage {
+}
+exports.TaskMessage = TaskMessage;
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsRequired)(),
+    __metadata("design:type", String)
+], TaskMessage.prototype, "id", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    __metadata("design:type", String)
+], TaskMessage.prototype, "status", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    __metadata("design:type", Date)
+], TaskMessage.prototype, "createdAt", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    __metadata("design:type", Date)
+], TaskMessage.prototype, "lastModifiedAt", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    __metadata("design:type", Number)
+], TaskMessage.prototype, "attempts", void 0);
+__decorate([
+    (0, class_pipe_1.IsType)(() => task_error_1.TaskError),
+    __metadata("design:type", task_error_1.TaskError)
+], TaskMessage.prototype, "internalError", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsType)(() => task_error_1.TaskError),
+    __metadata("design:type", Object)
+], TaskMessage.prototype, "error", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    (0, class_pipe_1.IsRequired)(),
+    __metadata("design:type", Object)
+], TaskMessage.prototype, "payload", void 0);
+__decorate([
+    (0, class_pipe_1.Expose)(),
+    __metadata("design:type", Number)
+], TaskMessage.prototype, "partitionId", void 0);

package/tasks/requests/task.request.d.ts

@@ -0,0 +1,17 @@
+import { IRequestContext } from '../../core/interfaces/request-context';
+import { ObjectNote } from '@rockster/class-memory';
+import { ITaskObject } from '../interfaces/task-object';
+import { TaskMessageFind } from '../models/task-message-find';
+import { ITaskMessage } from '@rockster/common/tasks';
+export declare class TaskRequest {
+    protected get database(): import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, unknown>> & {
+        $client: any;
+    };
+    find(object: ObjectNote<ITaskObject>, payload: TaskMessageFind, requestContext: IRequestContext): Promise<any>;
+    create(object: ObjectNote<ITaskObject>, payload: any, requestContext: IRequestContext): Promise<{
+        [x: string]: any;
+    }>;
+    retry(object: ObjectNote<ITaskObject>, message: ITaskMessage<any>, requestContext: IRequestContext): Promise<{
+        [x: string]: any;
+    }>;
+}

package/tasks/requests/task.request.js

@@ -0,0 +1,71 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRequest = void 0;
+const controller_decorator_1 = require("../../controllers/decorators/controller.decorator");
+const generate_entity_id_1 = require("../functions/generate-entity-id");
+const constants_1 = require("../constants");
+const parse_task_message_search_1 = require("../functions/parse-task-message-search");
+const drizzle_orm_1 = require("drizzle-orm");
+const common_1 = require("@rockster/common");
+const tasks_1 = require("@rockster/common/tasks");
+let TaskRequest = class TaskRequest {
+    get database() {
+        return constants_1.constants.database;
+    }
+    async find(object, payload, requestContext) {
+        const alias = 'task_message';
+        const where = (0, parse_task_message_search_1.parseTaskMessageSearch)(payload.search, alias, constants_1.constants.fields);
+        const tableName = object.naming.table;
+        const query = `SELECT * FROM ${tableName} ${alias} WHERE ${where.withParams}`;
+        const result = await this.database.execute(query);
+        return result.rows;
+    }
+    async create(object, payload, requestContext) {
+        const values = await this
+            .database
+            .insert(object.MessageSchema)
+            .values({
+            id: (0, generate_entity_id_1.generateEntityId)(),
+            partitionId: object.nextPartitionId(),
+            payload: payload
+        })
+            .returning();
+        return values[0];
+    }
+    async retry(object, message, requestContext) {
+        const condition = (0, drizzle_orm_1.eq)(object.MessageSchema.id, message.id);
+        const queryResult = await this
+            .database
+            .select()
+            .from(object.MessageSchema)
+            .where(condition)
+            .execute();
+        const storedMessage = queryResult[0];
+        if (!message || message.status !== tasks_1.TaskMessageStatus.failed) {
+            throw new common_1.BadRequestError({
+                message: `Reprocessing unavailable for this task`
+            });
+        }
+        const values = await this
+            .database
+            .update(object.MessageSchema)
+            .set({
+            payload: message.payload,
+            lastModifiedAt: new Date(),
+            status: tasks_1.TaskMessageStatus.pending
+        })
+            .where(condition)
+            .returning();
+        return values[0];
+    }
+};
+exports.TaskRequest = TaskRequest;
+exports.TaskRequest = TaskRequest = __decorate([
+    (0, controller_decorator_1.Controller)()
+], TaskRequest);

package/tasks/services/task-manager.service.d.ts

@@ -0,0 +1,10 @@
+import { ObjectNote } from "@rockster/class-memory";
+import { ITaskObject } from "../interfaces/task-object";
+import { ITaskNaming } from "../interfaces/task-naming";
+export declare class TaskManagerService {
+    configure(object: ObjectNote<ITaskObject>): Promise<void>;
+    protected createTableIfNotExists(tableName: string): Promise<void>;
+    protected createPartitionsIfNotExists(object: ObjectNote<ITaskObject>): Promise<void>;
+    protected checkPartitionExists(naming: ITaskNaming, partitionId: number): Promise<any>;
+    protected checkTableExists(name: string): Promise<any>;
+}

package/tasks/services/task-manager.service.js

@@ -0,0 +1,60 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManagerService = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const constants_1 = require("../constants");
+const get_check_table_exists_script_1 = require("../functions/get-check-table-exists-script");
+const get_create_table_script_1 = require("../functions/get-create-table-script");
+const get_partitions_of_table_script_1 = require("../functions/get-partitions-of-table-script");
+const get_create_table_partition_script_1 = require("../functions/get-create-table-partition-script");
+let TaskManagerService = class TaskManagerService {
+    async configure(object) {
+        const naming = object.naming;
+        await this.createTableIfNotExists(naming.table);
+        await this.createPartitionsIfNotExists(object);
+    }
+    async createTableIfNotExists(tableName) {
+        const tableExists = await this
+            .checkTableExists(tableName);
+        if (!tableExists) {
+            const createTableScript = (0, get_create_table_script_1.getCreateTablescript)(tableName);
+            await constants_1.constants.database.execute(createTableScript);
+        }
+    }
+    async createPartitionsIfNotExists(object) {
+        const settings = object.settings;
+        for (var partitionId = 1; partitionId <= settings.partitions; partitionId++) {
+            const exists = await this
+                .checkPartitionExists(object.naming, partitionId);
+            if (exists)
+                continue;
+            const createScript = (0, get_create_table_partition_script_1.getCreateTablePartitionScript)(object.naming, partitionId);
+            await constants_1.constants.database.execute(createScript);
+        }
+    }
+    async checkPartitionExists(naming, partitionId) {
+        const tableName = naming.partition(partitionId).table;
+        const script = (0, get_partitions_of_table_script_1.getPartitionsOfTableScript)(naming.table);
+        const result = await constants_1.constants.database.execute(script);
+        const partitions = result.rows;
+        return partitions.find((partition) => {
+            return partition.tableName === tableName;
+        });
+    }
+    async checkTableExists(name) {
+        const result = await constants_1.constants
+            .database
+            .execute((0, get_check_table_exists_script_1.getCheckTableExistsScript)(name));
+        return result.rows[0].exists;
+    }
+};
+exports.TaskManagerService = TaskManagerService;
+exports.TaskManagerService = TaskManagerService = __decorate([
+    (0, class_injector_1.Injectable)()
+], TaskManagerService);

package/tasks/services/task-runner.service.d.ts

@@ -0,0 +1,16 @@
+import { ObjectNote } from "@rockster/class-memory";
+import { ITaskObject } from "../interfaces/task-object";
+import { ITaskRunner } from "../interfaces/task-runner";
+import { TaskMessage } from "../models/task-message";
+type TaskRunner = {
+    object: ObjectNote<ITaskObject>;
+    runner: ITaskRunner<any>;
+};
+export declare class TaskRunnerService {
+    private static running;
+    tasks: TaskRunner[];
+    activeTimer(): void;
+    startRunner(object: ObjectNote<ITaskObject>): Promise<void>;
+    protected eachMessage(task: TaskRunner, message: TaskMessage<any>): Promise<void>;
+}
+export {};

package/tasks/services/task-runner.service.js

@@ -0,0 +1,88 @@
+"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 TaskRunnerService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRunnerService = void 0;
+const get_pending_task_script_1 = require("../functions/get-pending-task-script");
+const constants_1 = require("../constants");
+const tasks_1 = require("@rockster/common/tasks");
+const class_injector_1 = require("@rockster/class-injector");
+const drizzle_orm_1 = require("drizzle-orm");
+let TaskRunnerService = TaskRunnerService_1 = class TaskRunnerService {
+    constructor() {
+        this.tasks = [];
+    }
+    activeTimer() {
+        setInterval(async () => {
+            if (TaskRunnerService_1.running)
+                return;
+            TaskRunnerService_1.running = true;
+            const promises = [];
+            for (const task of this.tasks) {
+                const query = (0, get_pending_task_script_1.getPendingTaskScript)(task.object.naming);
+                const result = await constants_1.constants.database.execute(query);
+                const messages = result.rows;
+                messages.forEach((message) => {
+                    promises.push(this.eachMessage(task, message));
+                });
+            }
+            await Promise.all(promises);
+            TaskRunnerService_1.running = false;
+        }, 500);
+    }
+    async startRunner(object) {
+        const runner = await (0, class_injector_1.createInstance)(object.objectClass);
+        this.tasks.push({
+            object: object,
+            runner: runner
+        });
+    }
+    async eachMessage(task, message) {
+        const table = task
+            .object
+            .MessageSchema;
+        const stopwatch = getTimer();
+        try {
+            stopwatch.start();
+            await task
+                .runner
+                .onRun({
+                message: message.payload
+            });
+            await constants_1.constants
+                .database
+                .update(table)
+                .set({
+                status: tasks_1.TaskMessageStatus.completed,
+                lastModifiedAt: new Date(),
+                runtimeMS: stopwatch.stop()
+            }).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(table.id, message.id), (0, drizzle_orm_1.eq)(table.partitionId, message.partitionId)));
+        }
+        catch (error) {
+            const taskError = error;
+            taskError.infos = getErrorInfos(error).message;
+            const isExpose = error.constructor.name === 'TaskError';
+            await constants_1.constants
+                .database
+                .update(table)
+                .set({
+                status: tasks_1.TaskMessageStatus.failed,
+                lastModifiedAt: new Date(),
+                attempts: message.attempts + 1,
+                runtineMS: stopwatch.stop(),
+                internalError: taskError,
+                error: isExpose ? taskError : null
+            }).where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(table.id, message.id), (0, drizzle_orm_1.eq)(table.partitionId, message.partitionId)));
+        }
+    }
+};
+exports.TaskRunnerService = TaskRunnerService;
+TaskRunnerService.running = false;
+exports.TaskRunnerService = TaskRunnerService = TaskRunnerService_1 = __decorate([
+    (0, class_injector_1.Injectable)()
+], TaskRunnerService);

package/tasks/tasks.controller.d.ts

@@ -0,0 +1,19 @@
+import { Logger } from "@rockster/logger";
+import { ObjectLoader } from "../core/services/object-loader";
+import { ITaskObject } from "./interfaces/task-object";
+import { ObjectNote } from "@rockster/class-memory";
+import { Instantiable } from "@rockster/common";
+import { TaskManagerService } from "./services/task-manager.service";
+import { TaskRunnerService } from "./services/task-runner.service";
+export declare class TasksController extends ObjectLoader<ITaskObject> {
+    protected readonly taskManagerService: TaskManagerService;
+    protected readonly taskRunnerService: TaskRunnerService;
+    private static _objects;
+    protected objects: ObjectNote<ITaskObject>[];
+    protected logger: Logger;
+    constructor(taskManagerService: TaskManagerService, taskRunnerService: TaskRunnerService);
+    build(targets: Instantiable[]): Promise<void>;
+    start(): Promise<void>;
+    protected configureTasks(): Promise<void>;
+    protected initTasksRunners(): Promise<void>;
+}

package/tasks/tasks.controller.js

@@ -0,0 +1,75 @@
+"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 TasksController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TasksController = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const logger_1 = require("@rockster/logger");
+const object_loader_1 = require("../core/services/object-loader");
+const object_type_1 = require("../common/interfaces/enum/object-type");
+const task_manager_service_1 = require("./services/task-manager.service");
+const task_request_1 = require("./requests/task.request");
+const module_1 = require("../module");
+const node_postgres_1 = require("drizzle-orm/node-postgres");
+const constants_1 = require("./constants");
+const get_database_uri_1 = require("./functions/get-database-uri");
+const worker_threads_1 = require("worker_threads");
+const task_runner_service_1 = require("./services/task-runner.service");
+const get_database_connection_name_1 = require("./functions/get-database-connection-name");
+let TasksController = TasksController_1 = class TasksController extends object_loader_1.ObjectLoader {
+    constructor(taskManagerService, taskRunnerService) {
+        super();
+        this.taskManagerService = taskManagerService;
+        this.taskRunnerService = taskRunnerService;
+        this.objects = TasksController_1._objects;
+        this.logger = new logger_1.Logger('Task');
+    }
+    async build(targets) {
+        super.load(this.objects, object_type_1.ObjectType.task, targets);
+    }
+    async start() {
+        await module_1.ModuleController
+            .instance
+            .loadRequests([task_request_1.TaskRequest]);
+        const applicationName = (0, get_database_connection_name_1.getDatabaseConnectionName)(worker_threads_1.isMainThread);
+        const databaseUri = (0, get_database_uri_1.getDatabaseUri)(applicationName);
+        constants_1.constants.database = await (0, node_postgres_1.drizzle)(databaseUri);
+        if (worker_threads_1.isMainThread) {
+            await this.configureTasks();
+        }
+        else {
+            await this.initTasksRunners();
+            this.taskRunnerService.activeTimer();
+        }
+        this.logger.log('Tasks successfully initialized');
+    }
+    async configureTasks() {
+        for (const object of this.objects) {
+            await this
+                .taskManagerService
+                .configure(object);
+        }
+    }
+    async initTasksRunners() {
+        for (const object of this.objects) {
+            await this
+                .taskRunnerService
+                .startRunner(object);
+        }
+    }
+};
+exports.TasksController = TasksController;
+TasksController._objects = [];
+exports.TasksController = TasksController = TasksController_1 = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [task_manager_service_1.TaskManagerService,
+        task_runner_service_1.TaskRunnerService])
+], TasksController);

package/translations/entities/translation-config.entity.d.ts

@@ -0,0 +1,9 @@
+import { Locale } from "@rockster/common";
+import { ITranslationConfig } from "../interfaces/translation-config";
+export declare class TranslationConfig implements ITranslationConfig {
+    id: string;
+    referenceId: string;
+    keys?: string[];
+    locales?: Locale[];
+    default: Locale;
+}