@bejibun/core 0.1.72 → 0.2.0

package/CHANGELOG.md

@@ -3,6 +3,66 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [v0.2.0](https://github.com/Bejibun-Framework/bejibun-core/compare/v0.1.73...v0.2.0) - 2026-02-02
+
+### 🩹 Fixes
+- Invalid namespace for model - [#15](https://github.com/Bejibun-Framework/bejibun-core/issues/15)
+
+### 📖 Changes
+- Added dynamic model timestamps for `created_at`, `updated_at`, and `deleted_at`
+
+#### Breaking Changes :
+- No longer `BaseColumns` on `Model`
+
+#### What's New :
+- Epoch Timestamp Trait
+- Queue Jobs
+
+#### What is Epoch Timestamp Trait?
+Override default model timestamps for `created_at`, `updated_at`, and `deleted_at` to unix timestamp.
+
+Example :
+```text
+2026-01-01 12:00:00.000 +0000 -> 1767948151
+```
+
+#### How does Queue work?
+When you dispatch job, system will add the job to database and save its params.
+
+Then worker will run jobs on the database and called `handle` function with params from the database which saved before.
+
+Worker only run jobs when the job is available by using `available_at`. You can also delay the job by passing `.delay(seconds)`
+
+Example :
+```ts
+// Immediately
+await TestJob.dispatch(/*any params here*/).send();
+
+// With delay
+await TestJob.dispatch(/*any params here*/).delay(60 * 10 /*10 minutes*/).send();
+```
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/Bejibun-Framework/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
+## [v0.1.73](https://github.com/Bejibun-Framework/bejibun-core/compare/v0.1.72...v0.1.73) - 2026-02-02
+
+### 🩹 Fixes
+- Fix infinite nested router - [#14](https://github.com/Bejibun-Framework/bejibun-core/pull/14)
+
+### 📖 Changes
+
+### ❤️Contributors
+- Havea Crenata ([@crenata](https://github.com/crenata))
+
+**Full Changelog**: https://github.com/Bejibun-Framework/bejibun-core/blob/master/CHANGELOG.md
+
+---
+
 ## [v0.1.72](https://github.com/Bejibun-Framework/bejibun-core/compare/v0.1.71...v0.1.72) - 2026-01-29
 
 ### 🩹 Fixes
@@ -67,7 +127,7 @@ All notable changes to this project will be documented in this file.
 ### 📖 Changes
 #### What's New :
 - Added `Router.resource()`
-  
+
 Single line code that automatically generates a full set of CRUD.
 
 #### How to use?

package/README.md

@@ -274,22 +274,18 @@ Database table model
 Example :
 
 ```ts
-import BaseModel, {BaseColumns} from "@bejibun/core/bases/BaseModel";
-import {DateTime} from "luxon";
+import type {Timestamp, NullableTimestamp} from "@bejibun/core/bases/BaseModel";
+import BaseModel from "@bejibun/core/bases/BaseModel";
 
-export interface TestColumns extends BaseColumns {
-    name: string;
-}
-
-export default class TestModel extends BaseModel implements TestColumns {
+export default class TestModel extends BaseModel {
     public static tableName: string = "tests";
     public static idColumn: string = "id";
 
     declare id: bigint;
     declare name: string;
-    declare created_at: DateTime | string;
-    declare updated_at: DateTime | string;
-    declare deleted_at: DateTime | string | null;
+    declare created_at: Timestamp;
+    declare updated_at: Timestamp;
+    declare deleted_at: NullableTimestamp;
 }
 ```
 

package/bases/BaseJob.d.ts

@@ -0,0 +1,7 @@
+import JobBuilder from "../builders/JobBuilder";
+export default class BaseJob {
+    protected static _namespace: string;
+    static get namespace(): string;
+    static setNamespace(namespace: string): void;
+    static dispatch(...args: any): JobBuilder;
+}

package/bases/BaseJob.js

@@ -0,0 +1,17 @@
+import { isEmpty } from "@bejibun/utils";
+import JobBuilder from "../builders/JobBuilder";
+import RuntimeException from "../exceptions/RuntimeException";
+export default class BaseJob {
+    static _namespace;
+    static get namespace() {
+        if (isEmpty(this._namespace))
+            throw new RuntimeException(`Job namespace not registered for [${this.name}].`);
+        return this._namespace;
+    }
+    static setNamespace(namespace) {
+        this._namespace = namespace;
+    }
+    static dispatch(...args) {
+        return new JobBuilder().setQueue(this.namespace).dispatch(...args);
+    }
+}

package/bases/BaseModel.d.ts

@@ -1,27 +1,24 @@
-import { DateTime } from "luxon";
+import Luxon from "@bejibun/utils/facades/Luxon";
 import { Constructor, Model, ModelOptions, PartialModelObject, QueryBuilder, QueryBuilderType, QueryContext, TransactionOrKnex } from "objection";
 import SoftDeletes from "../facades/SoftDeletes";
-export interface BaseColumns {
-    id: bigint | number;
-    created_at: DateTime | string;
-    updated_at: DateTime | string;
-    deleted_at: DateTime | string | null;
-}
+export type Timestamp = typeof Luxon.DateTime | Date | string;
+export type NullableTimestamp = Timestamp | null;
 declare class BunQueryBuilder<M extends Model, R = M[]> extends SoftDeletes<M, R> {
     update(payload: PartialModelObject<M>): Promise<QueryBuilder<M, R>>;
 }
-export default class BaseModel extends Model implements BaseColumns {
+export default class BaseModel extends Model {
+    protected static _namespace: string;
     static tableName: string;
     static idColumn: string;
+    static createdColumn: string;
+    static updatedColumn: string;
     static deletedColumn: string;
     static QueryBuilder: typeof BunQueryBuilder;
     id: number | bigint;
-    created_at: DateTime | string;
-    updated_at: DateTime | string;
-    deleted_at: DateTime | string | null;
     static get namespace(): string;
     $beforeInsert(queryContext: QueryContext): void;
     $beforeUpdate(opt: ModelOptions, queryContext: QueryContext): void;
+    static setNamespace(namespace: string): void;
     static query<T extends Model>(this: Constructor<T>, trxOrKnex?: TransactionOrKnex): QueryBuilderType<T>;
     static withTrashed<T extends Model>(this: T): QueryBuilderType<T>;
     static onlyTrashed<T extends Model>(this: T): QueryBuilderType<T>;

package/bases/BaseModel.js

@@ -1,12 +1,9 @@
-import App from "@bejibun/app";
-import { defineValue, isEmpty } from "@bejibun/utils";
-import Str from "@bejibun/utils/facades/Str";
-import { DateTime } from "luxon";
+import { defineValue, isEmpty, isNotEmpty } from "@bejibun/utils";
+import Luxon from "@bejibun/utils/facades/Luxon";
 import { Model } from "objection";
-import { relative, sep } from "path";
-import { fileURLToPath } from "url";
 import ModelNotFoundException from "../exceptions/ModelNotFoundException";
 import SoftDeletes from "../facades/SoftDeletes";
+import RuntimeException from "../exceptions/RuntimeException";
 class BunQueryBuilder extends SoftDeletes {
     // @ts-ignore
     async update(payload) {
@@ -20,26 +17,34 @@ class BunQueryBuilder extends SoftDeletes {
 }
 // @ts-ignore
 export default class BaseModel extends Model {
+    static _namespace;
     static tableName;
     static idColumn;
+    static createdColumn = "created_at";
+    static updatedColumn = "updated_at";
     static deletedColumn = "deleted_at";
     static QueryBuilder = BunQueryBuilder;
     static get namespace() {
-        const filePath = fileURLToPath(import.meta.url);
-        const rel = relative(App.Path.rootPath(), filePath);
-        const withoutExt = rel.replace(/\.[tj]s$/, "");
-        const namespaces = withoutExt.split(sep);
-        namespaces.pop();
-        namespaces.push(this.name);
-        return namespaces.map(part => Str.toPascalCase(part)).join("/");
+        if (isEmpty(this._namespace))
+            throw new RuntimeException(`Model namespace not registered for [${this.name}]`);
+        return this._namespace;
     }
     $beforeInsert(queryContext) {
-        const now = DateTime.now();
-        this.created_at = now;
-        this.updated_at = now;
+        const now = Luxon.DateTime.now();
+        if (isNotEmpty(this[this.constructor.createdColumn])) {
+            this[this.constructor.createdColumn] = now;
+        }
+        if (isNotEmpty(this[this.constructor.updatedColumn])) {
+            this[this.constructor.updatedColumn] = now;
+        }
     }
     $beforeUpdate(opt, queryContext) {
-        this.updated_at = DateTime.now();
+        if (isNotEmpty(this[this.constructor.updatedColumn])) {
+            this[this.constructor.updatedColumn] = Luxon.DateTime.now();
+        }
+    }
+    static setNamespace(namespace) {
+        this._namespace = namespace;
     }
     static query(trxOrKnex) {
         return super.query(trxOrKnex);

package/bases/index.d.ts

@@ -1,3 +1,4 @@
 export * from "../bases/BaseController";
+export * from "../bases/BaseJob";
 export * from "../bases/BaseModel";
 export * from "../bases/BaseValidator";

package/bases/index.js

@@ -1,3 +1,4 @@
 export * from "../bases/BaseController";
+export * from "../bases/BaseJob";
 export * from "../bases/BaseModel";
 export * from "../bases/BaseValidator";

package/bootstrap.js

@@ -1,3 +1,7 @@
+import App from "@bejibun/app";
 import Database from "@bejibun/database";
 import BaseModel from "./bases/BaseModel";
+import NamespaceLoader from "./loader/NamespaceLoader";
 BaseModel.knex(Database.knex());
+await NamespaceLoader.load(App.Path.jobsPath());
+await NamespaceLoader.load(App.Path.modelsPath());

package/builders/JobBuilder.d.ts

@@ -0,0 +1,11 @@
+export default class JobBuilder {
+    protected queue?: string;
+    protected now: number;
+    protected availableAt: number;
+    protected args: Array<any>;
+    constructor();
+    setQueue(queue: string): JobBuilder;
+    dispatch(...args: any): JobBuilder;
+    delay(delay: number): JobBuilder;
+    send(): Promise<void>;
+}

package/builders/JobBuilder.js

@@ -0,0 +1,33 @@
+import Luxon from "@bejibun/utils/facades/Luxon";
+import JobModel from "../models/JobModel";
+export default class JobBuilder {
+    queue;
+    now;
+    availableAt;
+    args;
+    constructor() {
+        this.now = Luxon.DateTime.now().toUnixInteger();
+        this.availableAt = this.now;
+        this.args = [];
+    }
+    setQueue(queue) {
+        this.queue = queue;
+        return this;
+    }
+    dispatch(...args) {
+        this.args.push(...args);
+        return this;
+    }
+    delay(delay) {
+        this.availableAt = this.now + delay;
+        return this;
+    }
+    async send() {
+        await JobModel.create({
+            queue: this.queue,
+            payload: JSON.stringify(this.args),
+            available_at: this.availableAt,
+            created_at: this.now
+        });
+    }
+}

package/builders/NamespaceBuilder.d.ts

@@ -0,0 +1,5 @@
+export default class NamespaceBuilder {
+    private computeNamespace;
+    private walk;
+    load(directory: string): Promise<void>;
+}

package/builders/NamespaceBuilder.js

@@ -0,0 +1,37 @@
+import App from "@bejibun/app";
+import { isEmpty } from "@bejibun/utils";
+import { readdirSync } from "fs";
+import { join, relative, sep } from "path";
+import { pathToFileURL } from "url";
+export default class NamespaceBuilder {
+    computeNamespace(filePath) {
+        const rel = relative(App.Path.rootPath(), filePath);
+        const withoutExt = rel.replace(/\.[tj]s$/, "");
+        const parts = withoutExt.split(sep);
+        return parts.join("/");
+    }
+    async walk(directory) {
+        const entries = readdirSync(directory, { withFileTypes: true });
+        const files = await Promise.all(entries.map((entry) => {
+            const fullPath = join(directory, entry.name);
+            return entry.isDirectory() ?
+                this.walk(fullPath) :
+                ((fullPath.endsWith(".ts") ||
+                    fullPath.endsWith(".js")) ? [fullPath] : []);
+        }));
+        return files.flat();
+    }
+    async load(directory) {
+        const files = await this.walk(directory);
+        for (const file of files) {
+            const fileUrl = pathToFileURL(file).href;
+            const module = await import(fileUrl);
+            const Class = module.default;
+            if (isEmpty(Class))
+                continue;
+            const namespace = this.computeNamespace(file);
+            if (typeof Class.setNamespace === "function")
+                Class.setNamespace(namespace);
+        }
+    }
+}

package/builders/RouterBuilder.d.ts

@@ -1,6 +1,6 @@
 import type { TFacilitator, TPaywall, TX402Config } from "@bejibun/x402";
 import type { IMiddleware } from "../types/middleware";
-import type { HandlerType, ResourceAction, Route, RouterGroup } from "../types/router";
+import type { HandlerType, RawsRoute, ResourceAction, Route, RouterGroup } from "../types/router";
 import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
 import BaseController from "../bases/BaseController";
 export interface ResourceOptions {
@@ -8,9 +8,9 @@ export interface ResourceOptions {
     except?: Array<ResourceAction>;
 }
 export default class RouterBuilder {
-    private basePath;
-    private middlewares;
-    private baseNamespace;
+    protected basePath: string;
+    protected middlewares: Array<IMiddleware>;
+    protected baseNamespace: string;
     prefix(basePath: string): RouterBuilder;
     middleware(...middlewares: Array<IMiddleware>): RouterBuilder;
     namespace(baseNamespace: string): RouterBuilder;
@@ -29,12 +29,13 @@ export default class RouterBuilder {
     trace(path: string, handler: string | HandlerType): Route;
     match(methods: Array<HttpMethodEnum>, path: string, handler: string | HandlerType): RouterGroup;
     any(path: string, handler: string | HandlerType): RouterGroup;
-    serialize(routes: Route | Array<Route> | RouterGroup | Array<RouterGroup>): RouterGroup;
+    serialize(routes: Route | Array<Route> | RouterGroup | Array<RouterGroup> | Array<RawsRoute>): RouterGroup;
     private mergeRoutes;
     private joinPaths;
     private resolveControllerString;
     private resolveIncludedActions;
     private hasRaw;
+    private hasRaws;
     private isMethodMap;
     private applyGroup;
 }

package/builders/RouterBuilder.js

@@ -3,7 +3,6 @@ import Logger from "@bejibun/logger";
 import { defineValue, isEmpty, isModuleExists, isNotEmpty } from "@bejibun/utils";
 import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
 import Enum from "@bejibun/utils/facades/Enum";
-import path from "path";
 import RouterException from "../exceptions/RouterException";
 export default class RouterBuilder {
     basePath = "";
@@ -31,9 +30,36 @@ export default class RouterBuilder {
     group(routes) {
         const rawGroups = [];
         let routeGroups = {};
+        if (this.hasRaws(routes)) {
+            const routeList = Array.isArray(routes) ? routes.flat() : [routes];
+            const routerGroups = routeList.filter((value) => !this.hasRaws(value) && !this.hasRaw(value));
+            const rawRoutes = routeList.filter((value) => this.hasRaws(value)).map((value) => value.raws).flat();
+            const newRoutes = {};
+            for (const route of rawRoutes) {
+                const middlewares = this.middlewares.concat(defineValue(route.raw.middlewares, []));
+                const effectiveNamespace = defineValue(this.baseNamespace, route.raw.namespace);
+                const cleanPath = this.joinPaths(defineValue(route.raw.prefix, this.basePath), route.raw.path);
+                let resolvedHandler = typeof route.raw.handler === "string" ?
+                    this.resolveControllerString(route.raw.handler, effectiveNamespace) :
+                    route.raw.handler;
+                for (const middleware of [...middlewares].reverse()) {
+                    resolvedHandler = middleware.handle(resolvedHandler);
+                }
+                if (isEmpty(newRoutes[cleanPath]))
+                    newRoutes[cleanPath] = {};
+                Object.assign(newRoutes[cleanPath], {
+                    [route.raw.method]: resolvedHandler
+                });
+                route.raw.middlewares = middlewares;
+                route.raw.namespace = effectiveNamespace;
+                route.raw.path = cleanPath;
+                rawGroups.push(route);
+            }
+            routeGroups = Object.assign({}, ...routerGroups.map((value) => this.applyGroup(value)), newRoutes);
+        }
         if (this.hasRaw(routes)) {
             const routeList = Array.isArray(routes) ? routes.flat() : [routes];
-            const routerGroups = routeList.filter((value) => !this.hasRaw(value));
+            const routerGroups = routeList.filter((value) => !this.hasRaws(value) && !this.hasRaw(value));
             const rawRoutes = routeList.filter((value) => this.hasRaw(value));
             const newRoutes = {};
             for (const route of rawRoutes) {
@@ -196,13 +222,15 @@ export default class RouterBuilder {
         if (Array.isArray(routes)) {
             if (this.hasRaw(routes))
                 routes = routes.map((value) => value.route);
+            if (this.hasRaws(routes))
+                routes = routes.map((value) => value.routes).flat();
         }
         else {
             if (this.hasRaw(routes))
                 routes = routes.route;
+            if (this.hasRaws(routes))
+                routes = routes.routes;
         }
-        if ("raws" in routes)
-            routes = routes.routes;
         const mergedRoutes = this.mergeRoutes(routes);
         if (Array.isArray(mergedRoutes))
             return Object.assign({}, ...mergedRoutes);
@@ -238,7 +266,7 @@ export default class RouterBuilder {
         if (isEmpty(controllerName) || isEmpty(methodName)) {
             throw new RouterException(`Invalid router controller definition: ${definition}.`);
         }
-        const controllerPath = path.resolve(App.Path.rootPath(), defineValue(overrideNamespace, this.baseNamespace));
+        const controllerPath = App.Path.rootPath(defineValue(overrideNamespace, this.baseNamespace));
         let location = null;
         try {
             location = Bun.resolveSync(`./${controllerName}.ts`, controllerPath);
@@ -289,10 +317,17 @@ export default class RouterBuilder {
             typeof routes === "object" &&
             "raw" in routes);
     }
+    hasRaws(routes) {
+        if (Array.isArray(routes))
+            return routes.flat().some(route => isNotEmpty(route) && "raws" in route);
+        return (isNotEmpty(routes) &&
+            typeof routes === "object" &&
+            "raws" in routes);
+    }
     isMethodMap(value) {
         return (isNotEmpty(value) &&
             typeof value === "object" &&
-            Object.values(value).every(v => typeof v === "function"));
+            Object.values(value).every((v) => typeof v === "function"));
     }
     applyGroup(route) {
         if (isEmpty(route))
@@ -301,6 +336,7 @@ export default class RouterBuilder {
             const routeList = Array.isArray(route) ? route.flat() : [route];
             const rawRoutes = routeList.filter((value) => this.hasRaw(value));
             const newRoutes = {};
+            const rawGroups = [];
             for (const route of rawRoutes) {
                 const middlewares = route.raw.middlewares.concat(defineValue(this.middlewares, []));
                 const cleanPath = this.joinPaths(defineValue(route.raw.prefix, this.basePath), route.raw.path);
@@ -318,7 +354,16 @@ export default class RouterBuilder {
                 Object.assign(newRoutes[cleanPath], {
                     [route.raw.method]: resolvedHandler
                 });
+                route.raw.middlewares = middlewares;
+                route.raw.namespace = effectiveNamespace;
+                route.raw.path = cleanPath;
+                rawGroups.push(route);
             }
+            if (isNotEmpty(rawGroups))
+                return {
+                    raws: rawGroups,
+                    routes: newRoutes
+                };
             return newRoutes;
         }
         const result = {};

package/commands/make/MakeJobCommand.d.ts

@@ -0,0 +1,27 @@
+export default class MakeJobCommand {
+    /**
+     * The name and signature of the console command.
+     *
+     * @var $signature string
+     */
+    protected $signature: string;
+    /**
+     * The console command description.
+     *
+     * @var $description string
+     */
+    protected $description: string;
+    /**
+     * The options or optional flag of the console command.
+     *
+     * @var $options Array<Array<any>>
+     */
+    protected $options: Array<Array<any>>;
+    /**
+     * The arguments of the console command.
+     *
+     * @var $arguments Array<Array<string>>
+     */
+    protected $arguments: Array<Array<string>>;
+    handle(options: any, args: string): Promise<void>;
+}

package/commands/make/MakeJobCommand.js

@@ -0,0 +1,51 @@
+import App from "@bejibun/app";
+import Logger from "@bejibun/logger";
+import { isEmpty } from "@bejibun/utils";
+import Str from "@bejibun/utils/facades/Str";
+import path from "path";
+export default class MakeJobCommand {
+    /**
+     * The name and signature of the console command.
+     *
+     * @var $signature string
+     */
+    $signature = "make:job";
+    /**
+     * The console command description.
+     *
+     * @var $description string
+     */
+    $description = "Create a new job file";
+    /**
+     * The options or optional flag of the console command.
+     *
+     * @var $options Array<Array<any>>
+     */
+    $options = [];
+    /**
+     * The arguments of the console command.
+     *
+     * @var $arguments Array<Array<string>>
+     */
+    $arguments = [
+        ["<file>", "The name of the job file"]
+    ];
+    async handle(options, args) {
+        if (isEmpty(args)) {
+            Logger.setContext("APP").error("There is no filename provided.");
+            return;
+        }
+        const file = args;
+        const jobsDirectory = "jobs";
+        const template = Bun.file(path.resolve(__dirname, `../../stubs/${jobsDirectory}/TemplateJob.ts`));
+        if (!await template.exists()) {
+            Logger.setContext("APP").error("Whoops, something went wrong, the job template not found.");
+            return;
+        }
+        const name = Str.toPascalCase(file.replace(/\s+/g, "").replace(/job/gi, ""));
+        const destination = `${name}Job.ts`;
+        const content = await template.text();
+        await Bun.write(App.Path.jobsPath(destination), content.replace(/template/gi, name));
+        Logger.setContext("APP").info(`Job [app/jobs/${destination}] created successfully.`);
+    }
+}

package/commands/queue/QueueWorkCommand.d.ts

@@ -0,0 +1,27 @@
+export default class QueueWorkCommand {
+    /**
+     * The name and signature of the console command.
+     *
+     * @var $signature string
+     */
+    protected $signature: string;
+    /**
+     * The console command description.
+     *
+     * @var $description string
+     */
+    protected $description: string;
+    /**
+     * The options or optional flag of the console command.
+     *
+     * @var $options Array<Array<any>>
+     */
+    protected $options: Array<Array<any>>;
+    /**
+     * The arguments of the console command.
+     *
+     * @var $arguments Array<Array<string>>
+     */
+    protected $arguments: Array<Array<string>>;
+    handle(options: any, args: string): Promise<void>;
+}

package/commands/queue/QueueWorkCommand.js

@@ -0,0 +1,72 @@
+import App from "@bejibun/app";
+import Logger from "@bejibun/logger";
+import { defineValue, isEmpty, isNotEmpty } from "@bejibun/utils";
+import RuntimeException from "../../exceptions/RuntimeException";
+import JobModel from "../../models/JobModel";
+export default class QueueWorkCommand {
+    /**
+     * The name and signature of the console command.
+     *
+     * @var $signature string
+     */
+    $signature = "queue:work";
+    /**
+     * The console command description.
+     *
+     * @var $description string
+     */
+    $description = "Start processing jobs on the queue as a daemon";
+    /**
+     * The options or optional flag of the console command.
+     *
+     * @var $options Array<Array<any>>
+     */
+    $options = [];
+    /**
+     * The arguments of the console command.
+     *
+     * @var $arguments Array<Array<string>>
+     */
+    $arguments = [];
+    async handle(options, args) {
+        await import(App.Path.rootPath("bootstrap.ts"));
+        let running = true;
+        process.on("exit", async () => {
+            running = false;
+            Logger.setContext("Queue").info("Queue worker stopped.");
+        });
+        process.on("SIGINT", async () => {
+            running = false;
+            Logger.setContext("Queue").info("Stopping queue worker, SIGINT sent.");
+        });
+        process.on("SIGTERM", async () => {
+            running = false;
+            Logger.setContext("Queue").info("Stopping queue worker, SIGTERM sent.");
+        });
+        while (running) {
+            const job = await JobModel.query().where("attempts", "<", 3).orderBy("id", "asc").first();
+            if (isNotEmpty(job?.id)) {
+                const handler = async () => {
+                    const module = await import(App.Path.rootPath(job.queue));
+                    const Class = module.default;
+                    if (isEmpty(Class))
+                        throw new RuntimeException(`Job class not found [${job.queue}].`);
+                    const instance = new Class();
+                    if (typeof instance.handle !== "function")
+                        throw new RuntimeException(`Job class has no handle function in [${job.queue}].`);
+                    instance.handle(JSON.parse(job.payload));
+                };
+                try {
+                    await handler();
+                    await JobModel.query().findById(job.id).delete();
+                }
+                catch {
+                    await JobModel.query().findById(job.id).update({
+                        attempts: defineValue(Number(job.attempts), 0) + 1
+                    });
+                }
+            }
+        }
+        process.exit(0);
+    }
+}

package/index.d.ts

@@ -3,3 +3,4 @@ export * from "./enums/index";
 export * from "./exceptions/index";
 export * from "./facades/index";
 export * from "./middlewares/index";
+export * from "./models/index";

package/index.js

@@ -3,3 +3,4 @@ export * from "./enums/index";
 export * from "./exceptions/index";
 export * from "./facades/index";
 export * from "./middlewares/index";
+export * from "./models/index";

package/loader/NamespaceLoader.d.ts

@@ -0,0 +1,3 @@
+export default class NamespaceLoader {
+    static load(directory: string): Promise<void>;
+}

package/loader/NamespaceLoader.js

@@ -0,0 +1,6 @@
+import NamespaceBuilder from "../builders/NamespaceBuilder";
+export default class NamespaceLoader {
+    static async load(directory) {
+        return await new NamespaceBuilder().load(directory);
+    }
+}

package/models/EpochTimestamps.d.ts

@@ -0,0 +1,2 @@
+declare const EpochTimestamps: (Base: any) => any;
+export default EpochTimestamps;

package/models/EpochTimestamps.js

@@ -0,0 +1,20 @@
+import { isNotEmpty } from "@bejibun/utils";
+import Luxon from "@bejibun/utils/facades/Luxon";
+const EpochTimestamps = (Base) => class extends Base {
+    $beforeInsert(queryContext) {
+        const now = Luxon.DateTime.now().toUnixInteger();
+        if (isNotEmpty(this[this.constructor.createdColumn])) {
+            this[this.constructor.createdColumn] = now;
+        }
+        if (isNotEmpty(this[this.constructor.updatedColumn])) {
+            this[this.constructor.updatedColumn] = now;
+        }
+    }
+    $beforeUpdate(opt, queryContext) {
+        this.updated_at = Luxon.DateTime.now().toUnixInteger();
+        if (isNotEmpty(this[this.constructor.updatedColumn])) {
+            this[this.constructor.updatedColumn] = Luxon.DateTime.now().toUnixInteger();
+        }
+    }
+};
+export default EpochTimestamps;

package/models/JobModel.d.ts

@@ -0,0 +1,18 @@
+import { ModelOptions, QueryBuilder, QueryContext } from "objection";
+declare const JobModel_base: any;
+export default class JobModel extends JobModel_base {
+    static tableName: string;
+    static idColumn: string;
+    static updatedColumn: null;
+    static deletedColumn: null;
+    static QueryBuilder: typeof QueryBuilder;
+    $beforeUpdate(opt: ModelOptions, queryContext: QueryContext): void;
+    id: bigint;
+    queue: string;
+    payload: string;
+    attempts: bigint;
+    reserved_at: bigint | null;
+    available_at: bigint;
+    created_at: bigint;
+}
+export {};

package/models/JobModel.js

@@ -0,0 +1,13 @@
+import { QueryBuilder } from "objection";
+import BaseModel from "../bases/BaseModel";
+import EpochTimestamps from "../models/EpochTimestamps";
+export default class JobModel extends EpochTimestamps(BaseModel) {
+    static tableName = "jobs";
+    static idColumn = "id";
+    static updatedColumn = null;
+    static deletedColumn = null;
+    static QueryBuilder = QueryBuilder;
+    $beforeUpdate(opt, queryContext) {
+        // do nothing
+    }
+}

package/models/index.d.ts

@@ -0,0 +1 @@
+export * from "../models/JobModel";

package/models/index.js

@@ -0,0 +1 @@
+export * from "../models/JobModel";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.72",
+    "version": "0.2.0",
     "author": "Havea Crenata <havea.crenata@gmail.com>",
     "repository": {
         "type": "git",
@@ -15,8 +15,8 @@
         "@bejibun/database": "^0.1.19",
         "@bejibun/logger": "^0.1.22",
         "@bejibun/utils": "^0.1.28",
-        "@vinejs/vine": "^4.2.0",
-        "commander": "^14.0.2",
+        "@vinejs/vine": "^4.3.0",
+        "commander": "^14.0.3",
         "luxon": "^3.7.2",
         "objection": "^3.1.5"
     },

package/stubs/jobs/TemplateJob.ts

@@ -0,0 +1,12 @@
+import BaseJob from "@bejibun/core/bases/BaseJob";
+
+export default class TemplateJob extends BaseJob {
+    /**
+     * Execute the job.
+     *
+     * @var $arguments Array<any>
+     */
+    public async handle(args: Array<any>): Promise<void> {
+        //
+    }
+}

package/stubs/models/TemplateModel.ts

@@ -1,17 +1,13 @@
-import BaseModel, {BaseColumns} from "@bejibun/core/bases/BaseModel";
-import Luxon from "@bejibun/utils/facades/Luxon";
+import type {Timestamp, NullableTimestamp} from "@bejibun/core/bases/BaseModel";
+import BaseModel from "@bejibun/core/bases/BaseModel";
 
-export interface TemplateColumns extends BaseColumns {
-    name: string;
-}
-
-export default class TemplateModel extends BaseModel implements TemplateColumns {
+export default class TemplateModel extends BaseModel {
     public static tableName: string = "templates";
     public static idColumn: string = "id";
 
     declare id: bigint;
     declare name: string;
-    declare created_at: Luxon.DateTime | string;
-    declare updated_at: Luxon.DateTime | string;
-    declare deleted_at: Luxon.DateTime | string | null;
+    declare created_at: Timestamp;
+    declare updated_at: Timestamp;
+    declare deleted_at: NullableTimestamp;
 }

package/types/router.d.ts

@@ -15,4 +15,8 @@ export type Route = {
     raw: RawRoute,
     route: RouterGroup
 };
+export type RawsRoute = {
+    raws: Array<Route>,
+    routes: Array<RouterGroup>
+};
 export type ResourceAction = "index" | "store" | "show" | "update" | "destroy";