@webtypen/webframez-core 0.2.1 → 0.2.2

package/dist/Commands/QueueRunCommand.d.ts

@@ -0,0 +1,21 @@
+import { ConsoleCommand } from "./ConsoleCommand";
+export declare class QueueRunCommand extends ConsoleCommand {
+    static signature: string;
+    static description: string;
+    workerKey: string;
+    startTime: any;
+    currentJob: any;
+    jobTypes: any;
+    jobsExecuted: number;
+    jobsSucceeded: number;
+    jobsFailed: number;
+    lastJob: any;
+    log(message: string): void;
+    handle(): Promise<void>;
+    canStart(): boolean;
+    updateLock(): void;
+    random(min: number, max: number): number;
+    wait(ms: number): Promise<unknown>;
+    waitRun(): Promise<unknown>;
+    run(): Promise<void>;
+}

package/dist/Commands/QueueRunCommand.js

@@ -0,0 +1,213 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueRunCommand = void 0;
+const fs_1 = __importDefault(require("fs"));
+const moment_1 = __importDefault(require("moment"));
+const ConsoleCommand_1 = require("./ConsoleCommand");
+const QueueJobsRegisty_1 = require("../Queue/QueueJobsRegisty");
+const FileFunctions_1 = require("../Functions/FileFunctions");
+const QueueJob_1 = require("../Queue/QueueJob");
+const StringFunctions_1 = require("../Functions/StringFunctions");
+class QueueRunCommand extends ConsoleCommand_1.ConsoleCommand {
+    constructor() {
+        super(...arguments);
+        // State
+        this.workerKey = "main";
+        this.startTime = null;
+        this.currentJob = null;
+        this.jobTypes = {};
+        // Statistics
+        this.jobsExecuted = 0;
+        this.jobsSucceeded = 0;
+        this.jobsFailed = 0;
+        this.lastJob = null;
+    }
+    log(message) {
+        this.writeln(`[${(0, moment_1.default)().format("YYYY-MM-DD HH:mm:ss")}] ${message}`);
+    }
+    handle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.startTime = (0, moment_1.default)();
+            if (!this.canStart()) {
+                return;
+            }
+            this.log("Queue started");
+            yield this.run();
+        });
+    }
+    canStart() {
+        // Register Job-Types
+        for (let entry of QueueJobsRegisty_1.QueueJobsRegisty.getJobs()) {
+            this.jobTypes[entry.name] = entry;
+        }
+        const file = (0, FileFunctions_1.storageDir)("queue", `worker_${this.workerKey}.json`);
+        if (!fs_1.default.existsSync(file)) {
+            return true;
+        }
+        const json = JSON.parse(fs_1.default.readFileSync(file, "utf-8"));
+        if (!json || !json.updated_at) {
+            return true;
+        }
+        if (json.last_job) {
+            this.lastJob = json.last_job;
+        }
+        const diff = (0, moment_1.default)().diff((0, moment_1.default)(json.updated_at), "seconds");
+        if (diff && diff >= 30) {
+            return true;
+        }
+        return true;
+        this.writeln(`Worker '${this.workerKey}' is already running in Process${json.pid ? " " + json.pid : ""} (last update ${diff <= 180 ? diff + " seconds ago" : (diff / 60).toFixed(0) + " minutes ago"})`);
+        return false;
+    }
+    updateLock() {
+        if (!fs_1.default.existsSync((0, FileFunctions_1.storageDir)("queue"))) {
+            fs_1.default.mkdirSync((0, FileFunctions_1.storageDir)("queue"), { recursive: true });
+        }
+        fs_1.default.writeFileSync((0, FileFunctions_1.storageDir)("queue", `worker_${this.workerKey}.json`), JSON.stringify({
+            key: this.workerKey,
+            pid: process.pid,
+            started_at: this.startTime.format("YYYY-MM-DD HH:mm:ss"),
+            updated_at: (0, moment_1.default)().format("YYYY-MM-DD HH:mm:ss"),
+            current_job: this.currentJob
+                ? {
+                    _id: this.currentJob._id,
+                    started_at: this.currentJob.started_at,
+                }
+                : null,
+            last_job: this.lastJob,
+        }));
+    }
+    random(min, max) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+    wait(ms) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                setTimeout(() => resolve(true), ms);
+            });
+        });
+    }
+    waitRun() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                this.updateLock();
+                yield this.wait(5000);
+                resolve(true);
+            }));
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            while (true) {
+                this.updateLock();
+                const now = (0, moment_1.default)();
+                const check = yield QueueJob_1.QueueJob.aggregate([
+                    {
+                        $match: {
+                            status: "pending",
+                            jobclass: { $ne: null },
+                            $or: [
+                                {
+                                    start_at: null,
+                                },
+                                {
+                                    start_at: { $lte: now.toDate() },
+                                },
+                            ],
+                        },
+                    },
+                    {
+                        $limit: 1,
+                    },
+                ]);
+                if (!check || !check[0] || !check[0]._id) {
+                    this.currentJob = null;
+                    yield this.waitRun();
+                    continue;
+                }
+                yield this.wait(this.random(200, 600));
+                const job = yield QueueJob_1.QueueJob.where("_id", "=", check[0]._id).first();
+                if (!job || job.status !== "pending") {
+                    this.currentJob = null;
+                    yield this.waitRun();
+                    continue;
+                }
+                this.log(`Start Job #${job.number} - ${job.jobclass}`);
+                const startedAt = new Date();
+                const executionKey = (0, moment_1.default)().format("YYYYMMDDHHmmss") + StringFunctions_1.StringFunctions.random(24);
+                job.status = "running";
+                job.started_at = startedAt;
+                job.ended_at = null;
+                job.executions = [
+                    { key: executionKey, worker: this.workerKey, status: "running", started_at: startedAt },
+                    ...(job.executions && job.executions.length > 0 ? job.executions : []),
+                ];
+                yield job.save();
+                this.currentJob = {
+                    _id: job._id.toString(),
+                    execution_key: executionKey,
+                    started_at: startedAt,
+                    job_executions_count: job.executions.length,
+                };
+                let jobInstance = null;
+                const jobType = this.jobTypes && this.jobTypes[job.jobclass] ? this.jobTypes[job.jobclass] : null;
+                try {
+                    if (!jobType) {
+                        throw new Error(`QueueError: Invalid job-type ${job.jobclass}`);
+                    }
+                    jobInstance = new jobType();
+                    const result = yield jobInstance.handle(job);
+                    const endedAt = new Date();
+                    job.status = "finished";
+                    job.ended_at = endedAt;
+                    job.executions[0].status = "finished";
+                    job.executions[0].ended_at = endedAt;
+                    job.executions[0].log = jobInstance.getLog();
+                    job.executions[0].duration_ms = (0, moment_1.default)().diff((0, moment_1.default)(startedAt), "milliseconds");
+                    if (result && typeof result === "object" && result.__execute_again) {
+                        job.status = "pending";
+                        job.start_at = result.__execute_again;
+                    }
+                    yield job.save();
+                    this.jobsSucceeded++;
+                    this.log(`Finished Job #${job.number} - ${job.jobclass} - ${(job.executions[0].duration_ms / 1000).toFixed(2)}s`);
+                }
+                catch (e) {
+                    const errorMessage = e instanceof Error ? e.stack || e.message : String(e);
+                    const endedAt = new Date();
+                    job.status = "failed";
+                    job.ended_at = endedAt;
+                    job.executions[0].status = "failed";
+                    job.executions[0].ended_at = endedAt;
+                    job.executions[0].error = errorMessage;
+                    job.executions[0].duration_ms = (0, moment_1.default)().diff((0, moment_1.default)(startedAt), "milliseconds");
+                    if (jobInstance) {
+                        job.executions[0].log = jobInstance.getLog();
+                    }
+                    yield job.save();
+                    this.jobsFailed++;
+                    this.log(`Failed Job #${job.number} - ${job.jobclass} - ${(job.executions[0].duration_ms / 1000).toFixed(2)}s`);
+                }
+                this.jobsExecuted++;
+                this.currentJob = null;
+                yield this.waitRun();
+            }
+        });
+    }
+}
+exports.QueueRunCommand = QueueRunCommand;
+// Command
+QueueRunCommand.signature = "queue:run";
+QueueRunCommand.description = "Run a queue worker";

package/dist/ConsoleApplication.js

@@ -13,6 +13,7 @@ exports.ConsoleApplication = void 0;
 const { Command } = require("commander");
 const Config_1 = require("./Config");
 const BuildFinishCommand_1 = require("./Commands/BuildFinishCommand");
+const QueueJobsRegisty_1 = require("./Queue/QueueJobsRegisty");
 class ConsoleApplication {
     /**
      * Init the routes and start the http-server
@@ -60,6 +61,9 @@ class ConsoleApplication {
                 program.addCommand(consoleCommand);
             }
         }
+        if (options.jobs && options.jobs.length > 0) {
+            QueueJobsRegisty_1.QueueJobsRegisty.registerJob(options.jobs);
+        }
         program.parse();
     }
 }

package/dist/LambdaApplication.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LambdaApplication = void 0;
 const Config_1 = require("./Config");
+const QueueJobsRegisty_1 = require("./Queue/QueueJobsRegisty");
 const Router_1 = require("./Router/Router");
 class LambdaApplication {
     /**
@@ -17,7 +18,12 @@ class LambdaApplication {
             mode: "aws-lambda",
             kernel: options && options.kernel ? options.kernel : null,
             basename: options && options.basename ? options.basename : null,
+            routesFunction: options && options.routesFunction ? options.routesFunction : null,
+            tempDir: options && options.tempDir ? options.tempDir : null,
         });
+        if (options.jobs && options.jobs.length > 0) {
+            QueueJobsRegisty_1.QueueJobsRegisty.registerJob(options.jobs);
+        }
         return Router_1.Router.handleRequest(null, null, { event: event });
     }
 }

package/dist/Queue/BaseQueueJob.d.ts

@@ -0,0 +1,12 @@
+import { QueueJob } from "./QueueJob";
+export declare class BaseQueueJob {
+    attempts: number;
+    currentLog: string;
+    handle(job: any): Promise<any>;
+    static create(props?: any): Promise<QueueJob>;
+    log(...args: any): this;
+    getLog(): string | null;
+    executeAgain(value?: number, unit?: "year" | "years" | "y" | "month" | "months" | "M" | "week" | "weeks" | "w" | "day" | "days" | "d" | "hour" | "hours" | "h" | "minute" | "minutes" | "m" | "second" | "seconds" | "s"): {
+        __execute_again: Date;
+    };
+}

package/dist/Queue/BaseQueueJob.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseQueueJob = void 0;
+const moment_1 = __importDefault(require("moment"));
+const QueueJob_1 = require("./QueueJob");
+class BaseQueueJob {
+    constructor() {
+        this.attempts = 3;
+        this.currentLog = "";
+    }
+    handle(job) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    static create(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const last = yield QueueJob_1.QueueJob.where("number", "=", { $gte: 0 }).orderBy("number", "DESC").first();
+            const job = new QueueJob_1.QueueJob();
+            job.number = last && last.number ? last.number + 1 : 1;
+            job.jobclass = this.name;
+            job.status = "pending";
+            job.created_at = new Date();
+            if (props) {
+                for (let key in props) {
+                    job[key] = props[key];
+                }
+            }
+            yield job.save();
+            return job;
+        });
+    }
+    log(...args) {
+        let temp = "";
+        if (args) {
+            for (let entry of args) {
+                if (typeof entry === "object") {
+                    try {
+                        const str = JSON.stringify(entry);
+                        if (str.length > 150 || temp.length > 150) {
+                            temp += (temp && temp.trim() !== "" ? " " : "") + JSON.stringify(entry, null, 4);
+                        }
+                        else {
+                            temp += (temp && temp.trim() !== "" ? " " : "") + str;
+                        }
+                    }
+                    catch (e) {
+                        temp += (temp && temp.trim() !== "" ? " " : "") + "[object Object]";
+                    }
+                }
+                else {
+                    temp += (temp && temp.trim() !== "" ? " " : "") + entry.toString();
+                }
+            }
+        }
+        this.currentLog += temp + "\n";
+        return this;
+    }
+    getLog() {
+        return this.currentLog && this.currentLog.trim() !== "" ? this.currentLog : null;
+    }
+    executeAgain(value = 30, unit = "seconds") {
+        return { __execute_again: (0, moment_1.default)().add(value, unit).toDate() };
+    }
+}
+exports.BaseQueueJob = BaseQueueJob;

package/dist/Queue/QueueJob.d.ts

@@ -0,0 +1,4 @@
+import { Model } from "../Database/Model";
+export declare class QueueJob extends Model {
+    __table: string;
+}

package/dist/Queue/QueueJob.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueJob = void 0;
+const Model_1 = require("../Database/Model");
+class QueueJob extends Model_1.Model {
+    constructor() {
+        super(...arguments);
+        this.__table = "queue_jobs";
+    }
+}
+exports.QueueJob = QueueJob;

package/dist/Queue/QueueJobsRegisty.d.ts

@@ -0,0 +1,7 @@
+declare class QueueJobsRegistyFacade {
+    private jobs;
+    getJobs(): any[];
+    registerJob(data: any): this;
+}
+export declare const QueueJobsRegisty: QueueJobsRegistyFacade;
+export {};

package/dist/Queue/QueueJobsRegisty.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueJobsRegisty = void 0;
+class QueueJobsRegistyFacade {
+    constructor() {
+        this.jobs = [];
+    }
+    getJobs() {
+        return this.jobs;
+    }
+    registerJob(data) {
+        if (Array.isArray(data)) {
+            for (let el of data) {
+                this.jobs.push(el);
+            }
+        }
+        else {
+            this.jobs.push(data);
+        }
+        return this;
+    }
+}
+exports.QueueJobsRegisty = new QueueJobsRegistyFacade();

package/dist/WebApplication.js

@@ -7,6 +7,7 @@ exports.WebApplication = void 0;
 const http_1 = __importDefault(require("http"));
 const Config_1 = require("./Config");
 const Router_1 = require("./Router/Router");
+const QueueJobsRegisty_1 = require("./Queue/QueueJobsRegisty");
 class WebApplication {
     /**
      * Init the routes and start the http-server
@@ -24,6 +25,9 @@ class WebApplication {
             routesFunction: options && options.routesFunction ? options.routesFunction : null,
             tempDir: options && options.tempDir ? options.tempDir : null,
         });
+        if (options.jobs && options.jobs.length > 0) {
+            QueueJobsRegisty_1.QueueJobsRegisty.registerJob(options.jobs);
+        }
         const port = options && options.port ? options.port : 3000;
         this.server = http_1.default.createServer((req, res) => {
             Router_1.Router.handleRequest(req, res);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webtypen/webframez-core",
-    "version": "0.2.1",
+    "version": "0.2.2",
     "description": "The core package of the typescript based webframez (web-framework) by webtypen.de",
     "homepage": "https://webtypen.de/",
     "license": "MIT",
@@ -28,6 +28,7 @@
         "@types/mime-types": "^2.1.4",
         "@types/node": "^18.11.9",
         "@types/qs": "^6.9.7",
+        "moment": "^2.30.1",
         "ts-node": "^10.9.1",
         "typescript": "^4.9.3"
     },

package/src/Commands/QueueRunCommand.ts

@@ -0,0 +1,221 @@
+import fs from "fs";
+import moment from "moment";
+import { ConsoleCommand } from "./ConsoleCommand";
+import { QueueJobsRegisty } from "../Queue/QueueJobsRegisty";
+import { storageDir } from "../Functions/FileFunctions";
+import { QueueJob } from "../Queue/QueueJob";
+import { StringFunctions } from "../Functions/StringFunctions";
+
+export class QueueRunCommand extends ConsoleCommand {
+    // Command
+    static signature = "queue:run";
+    static description = "Run a queue worker";
+
+    // State
+    workerKey = "main";
+    startTime: any = null;
+    currentJob: any = null;
+    jobTypes: any = {};
+
+    // Statistics
+    jobsExecuted = 0;
+    jobsSucceeded = 0;
+    jobsFailed = 0;
+    lastJob: any = null;
+
+    log(message: string) {
+        this.writeln(`[${moment().format("YYYY-MM-DD HH:mm:ss")}] ${message}`);
+    }
+
+    async handle() {
+        this.startTime = moment();
+        if (!this.canStart()) {
+            return;
+        }
+
+        this.log("Queue started");
+        await this.run();
+    }
+
+    canStart() {
+        // Register Job-Types
+        for (let entry of QueueJobsRegisty.getJobs()) {
+            this.jobTypes[entry.name] = entry;
+        }
+
+        const file = storageDir("queue", `worker_${this.workerKey}.json`);
+        if (!fs.existsSync(file)) {
+            return true;
+        }
+
+        const json = JSON.parse(fs.readFileSync(file, "utf-8"));
+        if (!json || !json.updated_at) {
+            return true;
+        }
+
+        if (json.last_job) {
+            this.lastJob = json.last_job;
+        }
+
+        const diff = moment().diff(moment(json.updated_at), "seconds");
+        if (diff && diff >= 30) {
+            return true;
+        }
+
+        return true;
+        this.writeln(
+            `Worker '${this.workerKey}' is already running in Process${json.pid ? " " + json.pid : ""} (last update ${
+                diff <= 180 ? diff + " seconds ago" : (diff / 60).toFixed(0) + " minutes ago"
+            })`
+        );
+        return false;
+    }
+
+    updateLock() {
+        if (!fs.existsSync(storageDir("queue"))) {
+            fs.mkdirSync(storageDir("queue"), { recursive: true });
+        }
+
+        fs.writeFileSync(
+            storageDir("queue", `worker_${this.workerKey}.json`),
+            JSON.stringify({
+                key: this.workerKey,
+                pid: process.pid,
+                started_at: this.startTime.format("YYYY-MM-DD HH:mm:ss"),
+                updated_at: moment().format("YYYY-MM-DD HH:mm:ss"),
+                current_job: this.currentJob
+                    ? {
+                          _id: this.currentJob._id,
+                          started_at: this.currentJob.started_at,
+                      }
+                    : null,
+                last_job: this.lastJob,
+            })
+        );
+    }
+
+    random(min: number, max: number) {
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    }
+
+    async wait(ms: number) {
+        return new Promise((resolve) => {
+            setTimeout(() => resolve(true), ms);
+        });
+    }
+
+    async waitRun() {
+        return new Promise(async (resolve) => {
+            this.updateLock();
+            await this.wait(5000);
+            resolve(true);
+        });
+    }
+
+    async run() {
+        while (true) {
+            this.updateLock();
+
+            const now = moment();
+            const check = await QueueJob.aggregate([
+                {
+                    $match: {
+                        status: "pending",
+                        jobclass: { $ne: null },
+                        $or: [
+                            {
+                                start_at: null,
+                            },
+                            {
+                                start_at: { $lte: now.toDate() },
+                            },
+                        ],
+                    },
+                },
+                {
+                    $limit: 1,
+                },
+            ]);
+
+            if (!check || !check[0] || !check[0]._id) {
+                this.currentJob = null;
+                await this.waitRun();
+                continue;
+            }
+
+            await this.wait(this.random(200, 600));
+            const job = await QueueJob.where("_id", "=", check[0]._id).first();
+            if (!job || job.status !== "pending") {
+                this.currentJob = null;
+                await this.waitRun();
+                continue;
+            }
+
+            this.log(`Start Job #${job.number} - ${job.jobclass}`);
+            const startedAt = new Date();
+            const executionKey = moment().format("YYYYMMDDHHmmss") + StringFunctions.random(24);
+            job.status = "running";
+            job.started_at = startedAt;
+            job.ended_at = null;
+            job.executions = [
+                { key: executionKey, worker: this.workerKey, status: "running", started_at: startedAt },
+                ...(job.executions && job.executions.length > 0 ? job.executions : []),
+            ];
+            await job.save();
+
+            this.currentJob = {
+                _id: job._id.toString(),
+                execution_key: executionKey,
+                started_at: startedAt,
+                job_executions_count: job.executions.length,
+            };
+
+            let jobInstance: any = null;
+            const jobType: any = this.jobTypes && this.jobTypes[job.jobclass] ? this.jobTypes[job.jobclass] : null;
+            try {
+                if (!jobType) {
+                    throw new Error(`QueueError: Invalid job-type ${job.jobclass}`);
+                }
+
+                jobInstance = new jobType();
+                const result: any = await jobInstance.handle(job);
+
+                const endedAt = new Date();
+                job.status = "finished";
+                job.ended_at = endedAt;
+                job.executions[0].status = "finished";
+                job.executions[0].ended_at = endedAt;
+                job.executions[0].log = jobInstance.getLog();
+                job.executions[0].duration_ms = moment().diff(moment(startedAt), "milliseconds");
+
+                if (result && typeof result === "object" && result.__execute_again) {
+                    job.status = "pending";
+                    job.start_at = result.__execute_again;
+                }
+                await job.save();
+                this.jobsSucceeded++;
+                this.log(`Finished Job #${job.number} - ${job.jobclass} - ${(job.executions[0].duration_ms / 1000).toFixed(2)}s`);
+            } catch (e) {
+                const errorMessage = e instanceof Error ? e.stack || e.message : String(e);
+                const endedAt = new Date();
+                job.status = "failed";
+                job.ended_at = endedAt;
+                job.executions[0].status = "failed";
+                job.executions[0].ended_at = endedAt;
+                job.executions[0].error = errorMessage;
+                job.executions[0].duration_ms = moment().diff(moment(startedAt), "milliseconds");
+
+                if (jobInstance) {
+                    job.executions[0].log = jobInstance.getLog();
+                }
+                await job.save();
+                this.jobsFailed++;
+                this.log(`Failed Job #${job.number} - ${job.jobclass} - ${(job.executions[0].duration_ms / 1000).toFixed(2)}s`);
+            }
+
+            this.jobsExecuted++;
+            this.currentJob = null;
+            await this.waitRun();
+        }
+    }
+}

package/src/ConsoleApplication.ts

@@ -1,6 +1,7 @@
 const { Command } = require("commander");
 import { Config } from "./Config";
 import { BuildFinishCommand } from "./Commands/BuildFinishCommand";
+import { QueueJobsRegisty } from "./Queue/QueueJobsRegisty";
 
 export class ConsoleApplication {
     /**
@@ -56,6 +57,10 @@ export class ConsoleApplication {
             }
         }
 
+        if (options.jobs && options.jobs.length > 0) {
+            QueueJobsRegisty.registerJob(options.jobs);
+        }
+
         program.parse();
     }
 }

package/src/LambdaApplication.ts

@@ -1,23 +1,30 @@
 import { Config } from "./Config";
+import { QueueJobsRegisty } from "./Queue/QueueJobsRegisty";
 import { Router } from "./Router/Router";
 
 export class LambdaApplication {
-  /**
-   * Init the routes and handle the request
-   */
-  boot(event: any, context: any, options?: any) {
-    if (options && options.config) {
-      for (let key in options.config) {
-        Config.register(key, options.config[key]);
-      }
-    }
+    /**
+     * Init the routes and handle the request
+     */
+    boot(event: any, context: any, options?: any) {
+        if (options && options.config) {
+            for (let key in options.config) {
+                Config.register(key, options.config[key]);
+            }
+        }
+
+        Router.init({
+            mode: "aws-lambda",
+            kernel: options && options.kernel ? options.kernel : null,
+            basename: options && options.basename ? options.basename : null,
+            routesFunction: options && options.routesFunction ? options.routesFunction : null,
+            tempDir: options && options.tempDir ? options.tempDir : null,
+        });
 
-    Router.init({
-      mode: "aws-lambda",
-      kernel: options && options.kernel ? options.kernel : null,
-      basename: options && options.basename ? options.basename : null,
-    });
+        if (options.jobs && options.jobs.length > 0) {
+            QueueJobsRegisty.registerJob(options.jobs);
+        }
 
-    return Router.handleRequest(null, null, { event: event });
-  }
+        return Router.handleRequest(null, null, { event: event });
+    }
 }

package/src/Queue/BaseQueueJob.ts

@@ -0,0 +1,82 @@
+import moment from "moment";
+import { QueueJob } from "./QueueJob";
+
+export class BaseQueueJob {
+    attempts: number = 3;
+    currentLog = "";
+
+    async handle(job: any): Promise<any> {}
+
+    static async create(props?: any) {
+        const last = await QueueJob.where("number", "=", { $gte: 0 }).orderBy("number", "DESC").first();
+
+        const job = new QueueJob();
+        job.number = last && last.number ? last.number + 1 : 1;
+        job.jobclass = this.name;
+        job.status = "pending";
+        job.created_at = new Date();
+        if (props) {
+            for (let key in props) {
+                job[key] = props[key];
+            }
+        }
+        await job.save();
+        return job;
+    }
+
+    log(...args: any) {
+        let temp = "";
+        if (args) {
+            for (let entry of args) {
+                if (typeof entry === "object") {
+                    try {
+                        const str = JSON.stringify(entry);
+                        if (str.length > 150 || temp.length > 150) {
+                            temp += (temp && temp.trim() !== "" ? " " : "") + JSON.stringify(entry, null, 4);
+                        } else {
+                            temp += (temp && temp.trim() !== "" ? " " : "") + str;
+                        }
+                    } catch (e) {
+                        temp += (temp && temp.trim() !== "" ? " " : "") + "[object Object]";
+                    }
+                } else {
+                    temp += (temp && temp.trim() !== "" ? " " : "") + entry.toString();
+                }
+            }
+        }
+        this.currentLog += temp + "\n";
+        return this;
+    }
+
+    getLog() {
+        return this.currentLog && this.currentLog.trim() !== "" ? this.currentLog : null;
+    }
+
+    executeAgain(
+        value: number = 30,
+        unit:
+            | "year"
+            | "years"
+            | "y"
+            | "month"
+            | "months"
+            | "M"
+            | "week"
+            | "weeks"
+            | "w"
+            | "day"
+            | "days"
+            | "d"
+            | "hour"
+            | "hours"
+            | "h"
+            | "minute"
+            | "minutes"
+            | "m"
+            | "second"
+            | "seconds"
+            | "s" = "seconds"
+    ) {
+        return { __execute_again: moment().add(value, unit).toDate() };
+    }
+}

package/src/Queue/QueueJob.ts

@@ -0,0 +1,5 @@
+import { Model } from "../Database/Model";
+
+export class QueueJob extends Model {
+    __table = "queue_jobs";
+}

package/src/Queue/QueueJobsRegisty.ts

@@ -0,0 +1,20 @@
+class QueueJobsRegistyFacade {
+    private jobs: any[] = [];
+
+    getJobs() {
+        return this.jobs;
+    }
+
+    registerJob(data: any) {
+        if (Array.isArray(data)) {
+            for (let el of data) {
+                this.jobs.push(el);
+            }
+        } else {
+            this.jobs.push(data);
+        }
+        return this;
+    }
+}
+
+export const QueueJobsRegisty = new QueueJobsRegistyFacade();

package/src/WebApplication.ts

@@ -1,6 +1,7 @@
 import http, { Server } from "http";
 import { Config } from "./Config";
 import { Router } from "./Router/Router";
+import { QueueJobsRegisty } from "./Queue/QueueJobsRegisty";
 
 export class WebApplication {
     private server!: Server;
@@ -23,6 +24,10 @@ export class WebApplication {
             tempDir: options && options.tempDir ? options.tempDir : null,
         });
 
+        if (options.jobs && options.jobs.length > 0) {
+            QueueJobsRegisty.registerJob(options.jobs);
+        }
+
         const port = options && options.port ? options.port : 3000;
         this.server = http.createServer((req, res) => {
             Router.handleRequest(req, res);