@rockster/core 0.0.1

package/jobs/interfaces/job-object.d.ts

@@ -0,0 +1,6 @@
+import { ObjectType } from "../../common";
+import { IObject } from "../../core";
+export interface IJobObject extends IObject {
+    type: ObjectType.job;
+    cron: string;
+}

package/jobs/interfaces/job-object.js

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

package/jobs/interfaces/job.options.d.ts

@@ -0,0 +1 @@
+export type JobOptions = {};

package/jobs/interfaces/job.options.js

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

package/jobs/jobs.controller.d.ts

@@ -0,0 +1,18 @@
+import { ObjectLoader } from "../core";
+import { IJobObject } from "./interfaces/job-object";
+import { ObjectNote } from "@rockster/class-memory";
+import { Instantiable } from "@rockster/common";
+import { JobData } from "./interfaces/job-data";
+import { Logger } from "@rockster/logger";
+export declare class JobsController extends ObjectLoader<IJobObject> {
+    protected dispatching: boolean;
+    protected objects: ObjectNote<IJobObject>[];
+    protected logger: Logger;
+    build(targets: Instantiable[]): Promise<void>;
+    init(): Promise<void>;
+    configJobs(): Promise<void>;
+    checkContinue(): Promise<void>;
+    execute(jobName: string): Promise<Error>;
+    protected logFinal(jobName: string, error?: Error): void;
+    protected displayNextRun(job: JobData): void;
+}

package/jobs/jobs.controller.js

@@ -0,0 +1,122 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsController = void 0;
+const core_1 = require("../core");
+const common_1 = require("../common");
+const constants_1 = require("./constants");
+const cron_schedule_1 = require("cron-schedule");
+const moment_1 = __importDefault(require("moment"));
+const logger_1 = require("@rockster/logger");
+const worker_threads_1 = require("worker_threads");
+const dispatch_task_1 = require("../workers/functions/dispatch-task");
+const interfaces_1 = require("../workers/interfaces");
+const class_injector_1 = require("@rockster/class-injector");
+const milliseconds = 1000;
+let JobsController = class JobsController extends core_1.ObjectLoader {
+    constructor() {
+        super(...arguments);
+        this.dispatching = false;
+        this.objects = [];
+        this.logger = new logger_1.Logger('Jobs');
+    }
+    async build(targets) {
+        super.load(this.objects, common_1.ObjectType.job, targets);
+        this.each(async (object) => {
+            constants_1.jobs.push({ object });
+        });
+    }
+    async init() {
+        await this.configJobs();
+        setInterval(async () => {
+            if (this.dispatching)
+                return;
+            await this.checkContinue();
+        }, milliseconds);
+    }
+    async configJobs() {
+        for (const job of constants_1.jobs) {
+            job.name = job.object.objectKey;
+            if (worker_threads_1.isMainThread) {
+                job.cron = (0, cron_schedule_1.parseCronExpression)(job.object.cron);
+                job.isPending = false;
+                job.nextRun = job.cron.getNextDate();
+                job.shown = false;
+            }
+            if (worker_threads_1.isMainThread && !core.workers
+                || !worker_threads_1.isMainThread) {
+                job.instance = await (0, class_injector_1.createInstance)(job.object.objectClass);
+            }
+        }
+    }
+    async checkContinue() {
+        this.dispatching = true;
+        for (const job of constants_1.jobs) {
+            const nextRunTime = job.nextRun.getTime();
+            const nowTime = new Date().getTime();
+            const isTimeToRun = nowTime >= nextRunTime;
+            if (isTimeToRun && !job.isPending) {
+                if (core.workers) {
+                    await (0, dispatch_task_1.dispatchTask)({
+                        type: interfaces_1.WorkerMessageType.initRun,
+                        jobName: job.name
+                    }, async (message) => {
+                        job.isPending = false;
+                        this.logFinal(job.name, message.error);
+                        job.shown = false;
+                    });
+                }
+                else {
+                    const error = await this.execute(job.name);
+                    this.logFinal(job.name, error);
+                    job.shown = false;
+                    job.isPending = false;
+                }
+            }
+            this.displayNextRun(job);
+        }
+        this.dispatching = false;
+    }
+    async execute(jobName) {
+        try {
+            const job = constants_1.jobs
+                .find((job) => {
+                return job.name === jobName;
+            });
+            this.logger.log(`Starting job {${jobName}} execution...`);
+            await job.instance.execute();
+        }
+        catch (error) {
+            return error;
+        }
+    }
+    logFinal(jobName, error) {
+        if (error) {
+            this.logger.log(`Finished {${jobName}} execution with errors!`);
+            this.logger.error(error.message, error.stack);
+        }
+        else {
+            this.logger.log(`Finished {${jobName}} execution!`);
+        }
+    }
+    displayNextRun(job) {
+        if (job.shown) {
+            return;
+        }
+        job.shown = true;
+        const date = (0, moment_1.default)(job.nextRun);
+        this.logger.log(`{${job.name}} will be executed at {${date.format('LLLL')}}`);
+    }
+};
+exports.JobsController = JobsController;
+exports.JobsController = JobsController = __decorate([
+    (0, class_injector_1.Injectable)()
+], JobsController);

package/module/decorators/index.d.ts

@@ -0,0 +1,4 @@
+export * from './module.decorator';
+export * from './on-after-app-start';
+export * from './on-after-database-init';
+export * from './on-module-init';

package/module/decorators/index.js

@@ -0,0 +1,20 @@
+"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("./module.decorator"), exports);
+__exportStar(require("./on-after-app-start"), exports);
+__exportStar(require("./on-after-database-init"), exports);
+__exportStar(require("./on-module-init"), exports);

package/module/decorators/module.decorator.d.ts

@@ -0,0 +1,2 @@
+import { ModuleOptions } from "../interfaces";
+export declare const Module: (options: ModuleOptions) => (target: any) => void;

package/module/decorators/module.decorator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const common_1 = require("../../common");
+const Module = (options) => {
+    return (target) => {
+        const object = core
+            .storage
+            .createObject(target);
+        object.type = common_1.ObjectType.module;
+        object.options = options;
+        (0, class_injector_1.markInjectable)(target);
+    };
+};
+exports.Module = Module;

package/module/decorators/on-after-app-start.d.ts

@@ -0,0 +1 @@
+export declare const OnAfterAppStart: () => (target: any, propertyKey: string) => void;

package/module/decorators/on-after-app-start.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnAfterAppStart = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const global_1 = require("../../global");
+const OnAfterAppStart = () => {
+    return (target, propertyKey) => {
+        (0, class_injector_1.markExecutable)(target, propertyKey, global_1.ON_AFTER_APP_START);
+    };
+};
+exports.OnAfterAppStart = OnAfterAppStart;

package/module/decorators/on-after-database-init.d.ts

@@ -0,0 +1 @@
+export declare const OnAfterDatabaseInit: () => (target: any, propertyKey: string) => void;

package/module/decorators/on-after-database-init.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnAfterDatabaseInit = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const global_1 = require("../../global");
+const OnAfterDatabaseInit = () => {
+    return (target, propertyKey) => {
+        (0, class_injector_1.markExecutable)(target, propertyKey, global_1.ON_AFTER_DATABASE_INIT);
+    };
+};
+exports.OnAfterDatabaseInit = OnAfterDatabaseInit;

package/module/decorators/on-module-init.d.ts

@@ -0,0 +1 @@
+export declare const OnModuleInit: () => (target: any, propertyKey: string) => void;

package/module/decorators/on-module-init.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnModuleInit = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const global_1 = require("../../global");
+const OnModuleInit = () => {
+    return (target, propertyKey) => {
+        (0, class_injector_1.markExecutable)(target, propertyKey, global_1.ON_MODULE_INIT);
+    };
+};
+exports.OnModuleInit = OnModuleInit;

package/module/index.d.ts

@@ -0,0 +1,3 @@
+export * from './decorators';
+export * from './interfaces';
+export * from './module.controller';

package/module/index.js

@@ -0,0 +1,19 @@
+"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("./decorators"), exports);
+__exportStar(require("./interfaces"), exports);
+__exportStar(require("./module.controller"), exports);

package/module/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './module-events';
+export * from './module-object';
+export * from './module-options';

package/module/interfaces/index.js

@@ -0,0 +1,19 @@
+"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("./module-events"), exports);
+__exportStar(require("./module-object"), exports);
+__exportStar(require("./module-options"), exports);

package/module/interfaces/module-events.d.ts

@@ -0,0 +1,5 @@
+export type ModuleEvents = {
+    onModuleInit: () => Promise<void>;
+    onAfterAppStart: () => Promise<void>;
+    onAfterDatabaseInit: () => Promise<void>;
+};

package/module/interfaces/module-events.js

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

package/module/interfaces/module-object.d.ts

@@ -0,0 +1,7 @@
+import { ObjectType } from "../../common";
+import { IObject } from "../../core";
+import { ModuleOptions } from "./module-options";
+export interface IModuleObject extends IObject {
+    type: ObjectType.module;
+    options: ModuleOptions;
+}

package/module/interfaces/module-object.js

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

package/module/interfaces/module-options.d.ts

@@ -0,0 +1,8 @@
+import { Bootable, Instantiable } from '@rockster/common';
+export type ModuleOptions = {
+    entities?: Bootable[];
+    controllers?: Bootable[];
+    imports?: Instantiable[];
+    jobs?: Bootable[];
+    tasks?: Bootable[];
+};

package/module/interfaces/module-options.js

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

package/module/module.controller.d.ts

@@ -0,0 +1,31 @@
+import { Bootable, Instantiable } from "@rockster/common";
+import { Logger } from "@rockster/logger";
+import { DatabaseController } from "../database/database.controller";
+import { ObjectNote } from "@rockster/class-memory";
+import { IModuleObject, ModuleEvents } from "./interfaces";
+import { ControllerController } from "../controllers";
+import { JobsController } from "../jobs/jobs.controller";
+import { TasksController } from "../tasks/tasks.controller";
+export declare class ModuleController {
+    protected databaseController: DatabaseController;
+    protected requestController: ControllerController;
+    protected jobsController: JobsController;
+    protected tasksController: TasksController;
+    logger: Logger;
+    /**That's way is a temp fix to solve circular dependencies. We will fix on next version */
+    static instance: ModuleController;
+    constructor(databaseController: DatabaseController, requestController: ControllerController, jobsController: JobsController, tasksController: TasksController);
+    load(module: Instantiable, requests?: boolean, events?: ModuleEvents[]): Promise<ModuleEvents[]>;
+    protected loadOnlyRequests(module: Instantiable): Promise<void>;
+    protected loadOnlyEntities(module: Instantiable): Promise<void>;
+    protected loadJobsAndTasks(module: Instantiable): Promise<void>;
+    protected eachImport(imports: Instantiable[], callback: (target: any) => Promise<void>): Promise<void>;
+    protected runAfterDecorators(): void;
+    protected getModuleObject(module: Instantiable): ObjectNote<IModuleObject>;
+    protected loadEntities(entities: Instantiable[]): void;
+    loadRequests(requests: Instantiable[]): Promise<void>;
+    protected loadJobs(jobs: Instantiable[]): Promise<void>;
+    protected loadTasks(tasks: Instantiable[]): Promise<void>;
+    protected getObjects(bootables?: Bootable[]): Instantiable[];
+    protected getEvents(module: Instantiable, events: ModuleEvents[]): Promise<ModuleEvents>;
+}

package/module/module.controller.js

@@ -0,0 +1,159 @@
+"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 ModuleController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleController = void 0;
+const class_injector_1 = require("@rockster/class-injector");
+const logger_1 = require("@rockster/logger");
+const database_controller_1 = require("../database/database.controller");
+const common_1 = require("../common");
+const functions_1 = require("@rockster/class-injector/functions");
+const global_1 = require("../global");
+const controllers_1 = require("../controllers");
+const jobs_controller_1 = require("../jobs/jobs.controller");
+const tasks_controller_1 = require("../tasks/tasks.controller");
+let ModuleController = ModuleController_1 = class ModuleController {
+    constructor(databaseController, requestController, jobsController, tasksController) {
+        this.databaseController = databaseController;
+        this.requestController = requestController;
+        this.jobsController = jobsController;
+        this.tasksController = tasksController;
+        this.logger = new logger_1.Logger('Module');
+        ModuleController_1.instance = this;
+    }
+    async load(module, requests = true, events = []) {
+        try {
+            // Load imports
+            const object = this.getModuleObject(module);
+            if (object.options.imports?.length > 0) {
+                for (const importModule of object.options.imports) {
+                    await this.load(importModule, requests, events);
+                }
+            }
+            // Load module
+            const handles = await this.getEvents(module, events);
+            if (handles.onModuleInit) {
+                await handles.onModuleInit();
+            }
+            await this.loadOnlyEntities(module);
+            if (requests)
+                await this.loadOnlyRequests(module);
+            await this.loadJobsAndTasks(module);
+            this.logger.log(`[${module.name.replace(/module/gi, '')}] successfully initialized`);
+            return events;
+        }
+        catch (error) {
+            this.logger.throw(error);
+        }
+    }
+    async loadOnlyRequests(module) {
+        const object = this.getModuleObject(module);
+        const requests = this.getObjects(object.options.controllers);
+        this.runAfterDecorators();
+        await this.loadRequests(requests);
+    }
+    async loadOnlyEntities(module) {
+        const object = this.getModuleObject(module);
+        await this
+            .eachImport(object.options.imports, async (target) => {
+            await this.loadOnlyEntities(target);
+        });
+        const entities = this.getObjects(object.options.entities);
+        this.runAfterDecorators();
+        await this.loadEntities(entities);
+    }
+    async loadJobsAndTasks(module) {
+        const object = this.getModuleObject(module);
+        await this
+            .eachImport(object.options.imports, async (target) => {
+            await this.loadJobsAndTasks(target);
+        });
+        const jobs = this.getObjects(object.options.jobs);
+        const tasks = this.getObjects(object.options.tasks);
+        this.runAfterDecorators();
+        await this.loadJobs(jobs);
+        await this.loadTasks(tasks);
+    }
+    async eachImport(imports, callback) {
+        if (imports?.length > 0) {
+            for (const target of imports) {
+                await callback(target);
+            }
+        }
+    }
+    runAfterDecorators() {
+        core.runAfterDecorators.forEach((runAfterDecorators) => {
+            runAfterDecorators.handle();
+            runAfterDecorators.isExecuted = true;
+        });
+    }
+    getModuleObject(module) {
+        const logger = new logger_1.Logger('Module');
+        const object = core
+            .storage
+            .findObject(module);
+        if (object?.type !== common_1.ObjectType.module) {
+            logger.throw(new Error(`${module.name} is not a valid module. Use @Module to fix it.`));
+        }
+        return object;
+    }
+    loadEntities(entities) {
+        this.databaseController.build(entities);
+    }
+    loadRequests(requests) {
+        return this.requestController.build(requests);
+    }
+    loadJobs(jobs) {
+        return this.jobsController.build(jobs);
+    }
+    loadTasks(tasks) {
+        return this.tasksController.build(tasks);
+    }
+    getObjects(bootables) {
+        if (!bootables) {
+            return [];
+        }
+        return loadObjects(bootables)
+            .map((bootable) => {
+            return bootable.default;
+        });
+    }
+    async getEvents(module, events) {
+        const instance = await (0, functions_1.createExecutors)(module);
+        const handles = {
+            onModuleInit: () => {
+                return instance.executors[global_1.ON_MODULE_INIT]
+                    ? instance.executors[global_1.ON_MODULE_INIT].handle(null)
+                    : null;
+            },
+            onAfterAppStart: () => {
+                return instance.executors[global_1.ON_AFTER_APP_START]
+                    ? instance.executors[global_1.ON_AFTER_APP_START].handle(null)
+                    : null;
+            },
+            onAfterDatabaseInit: () => {
+                return instance.executors[global_1.ON_AFTER_DATABASE_INIT]
+                    ? instance.executors[global_1.ON_AFTER_DATABASE_INIT].handle(null)
+                    : null;
+            }
+        };
+        events.push(handles);
+        return handles;
+    }
+};
+exports.ModuleController = ModuleController;
+exports.ModuleController = ModuleController = ModuleController_1 = __decorate([
+    (0, class_injector_1.Injectable)(),
+    __metadata("design:paramtypes", [database_controller_1.DatabaseController,
+        controllers_1.ControllerController,
+        jobs_controller_1.JobsController,
+        tasks_controller_1.TasksController])
+], ModuleController);

package/package.json

@@ -0,0 +1,70 @@
+{
+   "name": "@rockster/core",
+   "version": "0.0.1",
+   "main": "index",
+   "types": "index.d.ts",
+   "scripts": {
+      "pre:build": "rm -rf ./dist && mkdir ./dist && cp package.json ./dist",
+      "build:prod": "npm run pre:build && tsc -p tsconfig.prod.json",
+      "build:dev": "npm run pre:build && tsc -p tsconfig.prod.json -w",
+      "post:publish": "cd ./dist && npm publish"
+   },
+   "author": "Hubseat",
+   "license": "MIT",
+   "publishConfig": {
+      "access": "public"
+   },
+   "repository": {
+      "type": "git",
+      "url": "https://git.hubseat.io/rockster/rockster-core"
+   },
+   "dependencies": {
+      "@dr.pogodin/csurf": "^1.13.0",
+      "@formatjs/intl": "^2.9.0",
+      "@google-cloud/storage": "^7.5.0",
+      "@paralleldrive/cuid2": "^2.2.2",
+      "@rockster/class-injector": "0.0.1",
+      "@rockster/class-memory": "0.0.1",
+      "@rockster/class-pipe": "^0.0.1",
+      "@rockster/common": "0.0.1",
+      "@rockster/logger": "0.0.1",
+      "@types/body-parser": "^1.19.2",
+      "@types/busboy": "^1.5.2",
+      "@types/cors": "^2.8.13",
+      "@types/dot-object": "^2.1.2",
+      "@types/express": "^4.17.21",
+      "@types/lodash": "^4.14.195",
+      "@types/node": "^20.8.10",
+      "@types/uuid": "^10.0.0",
+      "@types/validator": "^13.11.1",
+      "@types/ws": "^8.5.5",
+      "axios": "^1.5.1",
+      "body-parser": "^1.20.2",
+      "busboy": "^1.6.0",
+      "cors": "^2.8.5",
+      "cron-schedule": "^3.0.6",
+      "dot-object": "^2.1.4",
+      "drizzle-orm": "^0.39.2",
+      "express": "^4.18.2",
+      "helmet": "^7.0.0",
+      "lodash": "^4.17.21",
+      "moment": "^2.29.4",
+      "mongodb": "^5.5.0",
+      "nanoid": "^3.3.8",
+      "pg": "^8.11.0",
+      "radash": "^12.1.0",
+      "redis": "^4.6.7",
+      "typeorm": "^0.3.16",
+      "uuid": "^10.0.0",
+      "validator": "^13.11.0",
+      "ws": "^8.13.0",
+      "zod": "^3.23.8",
+      "inflection": "^3.0.2",
+      "typeorm-naming-strategies": "^4.1.0",
+      "msgpackr": "^1.11.5",
+      "path-to-regexp": "^8.3.0"
+   },
+   "devDependencies": {
+      "typescript": "^5.2.2"
+   }
+}

package/query/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const QUERY_CONTENT_KEY = "QUERY_CONTENT";
+export declare const QUERY_ACTION_TYPE = "QUERY_ACTION";

package/query/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUERY_ACTION_TYPE = exports.QUERY_CONTENT_KEY = void 0;
+exports.QUERY_CONTENT_KEY = 'QUERY_CONTENT';
+exports.QUERY_ACTION_TYPE = 'QUERY_ACTION';

package/query/decorators/index.d.ts

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

package/query/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("./query-content.decorator"), exports);

package/query/decorators/query-content.decorator.d.ts

@@ -0,0 +1 @@
+export declare const QueryContent: () => (target: any, propertyKey: string, index: number) => void;