@bejibun/core 0.1.21 → 0.1.22

package/dist/bases/BaseController.d.ts

@@ -0,0 +1,10 @@
+import { VineValidator } from "@vinejs/vine";
+import { BunRequest } from "bun";
+import Response from "../facades/Response";
+export default class BaseController {
+    parse(request: BunRequest): Promise<Record<string, any>>;
+    get response(): typeof Response;
+    validate(validator: VineValidator<any, Record<string, any> | undefined>, body: Record<string, any>): Promise<any>;
+    private serialize;
+    private parseForm;
+}

package/dist/bases/BaseController.js

@@ -0,0 +1,126 @@
+import { DateTime } from "luxon";
+import ValidatorException from "../exceptions/ValidatorException";
+import Response from "../facades/Response";
+import { defineValue, isEmpty, isNotEmpty } from "../utils/utils";
+export default class BaseController {
+    async parse(request) {
+        const contentType = defineValue(request.headers.get("content-type"), "");
+        const formData = new FormData();
+        try {
+            if (contentType.includes("application/json"))
+                return await request.json();
+            for (const [key, value] of Object.entries(request.params)) {
+                formData.append(key, value);
+            }
+            const url = new URL(request.url);
+            for (const [key, value] of url.searchParams) {
+                formData.append(key, value);
+            }
+            if (contentType.includes("multipart/form-data") ||
+                contentType.includes("application/x-www-form-urlencoded")) {
+                const body = await request.formData();
+                for (const [key, value] of body) {
+                    formData.append(key, value);
+                }
+            }
+            const text = await request.text();
+            if (isNotEmpty(text))
+                formData.append("text", text);
+        }
+        catch {
+            // do nothing
+        }
+        return this.parseForm(formData);
+    }
+    get response() {
+        return Response;
+    }
+    async validate(validator, body) {
+        try {
+            return await validator.validate(body);
+        }
+        catch (error) {
+            throw new ValidatorException(error.messages[0].message);
+        }
+    }
+    serialize(data) {
+        if (Array.isArray(data))
+            return data.map((value) => this.serialize(value));
+        if (data === null || data === undefined)
+            return null;
+        if (data instanceof DateTime)
+            return data.isValid ? data.toISO() : null;
+        if (data instanceof Date)
+            return Number.isNaN(data.getTime()) ? null : data.toISOString();
+        if (typeof data === "object" && !(data instanceof File)) {
+            if (Object.keys(data).length === 0)
+                return null;
+            const nested = {};
+            Object.keys(data).forEach((key) => {
+                nested[key] = this.serialize(data[key]);
+            });
+            return nested;
+        }
+        if (typeof data === "string") {
+            const trimmed = data.trim();
+            if (trimmed === "")
+                return null;
+            if (trimmed === "true")
+                return true;
+            if (trimmed === "false")
+                return false;
+            const numeric = Number(trimmed);
+            if (!Number.isNaN(numeric) && trimmed === numeric.toString())
+                return numeric;
+            return trimmed;
+        }
+        return data;
+    }
+    parseForm(formData) {
+        const result = {};
+        for (const [key, value] of formData.entries()) {
+            const keys = key.replace(/]/g, "").split("[");
+            let current = result;
+            for (let i = 0; i < keys.length; i++) {
+                const part = keys[i];
+                const nextPart = keys[i + 1];
+                if (i === keys.length - 1) {
+                    let convertedValue;
+                    if (value instanceof File) {
+                        convertedValue = value;
+                    }
+                    else if (value.trim() === "") {
+                        convertedValue = null;
+                    }
+                    else if (Number.isNaN(value)) {
+                        convertedValue = Number(value);
+                    }
+                    else if (value === "true" || value === "false") {
+                        convertedValue = value === "true";
+                    }
+                    else {
+                        try {
+                            convertedValue = JSON.parse(value);
+                        }
+                        catch {
+                            convertedValue = value;
+                        }
+                    }
+                    if (current[part] === undefined)
+                        current[part] = convertedValue;
+                    else if (Array.isArray(current[part]))
+                        current[part].push(convertedValue);
+                    else
+                        current[part] = [current[part], convertedValue];
+                }
+                else {
+                    const isArrayIndex = /^\d+$/.test(nextPart);
+                    if (isEmpty(current[part]))
+                        current[part] = isArrayIndex ? [] : {};
+                    current = current[part];
+                }
+            }
+        }
+        return result;
+    }
+}

package/dist/bases/BaseModel.d.ts

@@ -0,0 +1,33 @@
+import { DateTime } from "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;
+}
+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 {
+    static tableName: string;
+    static idColumn: 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 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>;
+    static all<T extends Model>(this: T): QueryBuilderType<T>;
+    static create<T extends Model>(this: T, payload: Record<string, any>): QueryBuilderType<T>;
+    static find<T extends Model>(this: T, id: bigint | number | string): QueryBuilderType<T>;
+    static findOrFail<T extends Model>(this: T, id: bigint | number | string): Promise<T>;
+}
+export {};

package/dist/bases/BaseModel.js

@@ -0,0 +1,68 @@
+import { DateTime } from "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 Str from "../facades/Str";
+import { defineValue, isEmpty } from "../utils/utils";
+class BunQueryBuilder extends SoftDeletes {
+    // @ts-ignore
+    async update(payload) {
+        const cloneQuery = this.clone();
+        const beforeRows = await cloneQuery;
+        if (isEmpty(beforeRows))
+            return defineValue(beforeRows);
+        await super.update(payload);
+        return cloneQuery;
+    }
+}
+// @ts-ignore
+class BaseModel extends Model {
+    static get namespace() {
+        const filePath = fileURLToPath(import.meta.url);
+        const appRoot = process.cwd();
+        const rel = relative(appRoot, 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("/");
+    }
+    $beforeInsert(queryContext) {
+        const now = DateTime.now();
+        this.created_at = now;
+        this.updated_at = now;
+    }
+    $beforeUpdate(opt, queryContext) {
+        this.updated_at = DateTime.now();
+    }
+    static query(trxOrKnex) {
+        return super.query(trxOrKnex);
+    }
+    ;
+    static withTrashed() {
+        return this.query().withTrashed();
+    }
+    static onlyTrashed() {
+        return this.query().onlyTrashed();
+    }
+    static all() {
+        return this.query().select();
+    }
+    static create(payload) {
+        return this.query().insert(payload);
+    }
+    static find(id) {
+        return this.query().findById(id);
+    }
+    static async findOrFail(id) {
+        const result = await this.find(id);
+        if (isEmpty(result))
+            throw new ModelNotFoundException(`[ModelNotFoundException]: No query results for model [${this.namespace}] [${id}].`);
+        return result;
+    }
+}
+BaseModel.deletedColumn = "deleted_at";
+BaseModel.QueryBuilder = BunQueryBuilder;
+export default BaseModel;

package/dist/bases/BaseValidator.d.ts

@@ -0,0 +1,5 @@
+import vine from "@vinejs/vine";
+import "../utils/vine";
+export default class BaseValidator {
+    static get validator(): typeof vine;
+}

package/dist/bases/BaseValidator.js

@@ -0,0 +1,7 @@
+import vine from "@vinejs/vine";
+import "../utils/vine";
+export default class BaseValidator {
+    static get validator() {
+        return vine;
+    }
+}

package/dist/bootstrap.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bootstrap.js

@@ -0,0 +1,11 @@
+import BaseModel from "./bases/BaseModel";
+import fs from "fs";
+import knex from "knex";
+import path from "path";
+const configPath = path.resolve(process.cwd(), "config/database.ts");
+let config;
+if (fs.existsSync(configPath))
+    config = require(configPath).default;
+else
+    config = require("./config/database").default;
+BaseModel.knex(knex(config));

package/dist/builders/ChalkBuilder.d.ts

@@ -0,0 +1,14 @@
+export default class ChalkBuilder {
+    protected value: string;
+    protected isNewLine: boolean;
+    protected clk: any;
+    constructor();
+    setValue(value: string): ChalkBuilder;
+    inline(): ChalkBuilder;
+    bold(): ChalkBuilder;
+    danger(): ChalkBuilder;
+    info(): ChalkBuilder;
+    line(): void;
+    show(): string;
+    private get _value();
+}

package/dist/builders/ChalkBuilder.js

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import os from "os";
+export default class ChalkBuilder {
+    constructor() {
+        this.value = "";
+        this.isNewLine = true;
+    }
+    setValue(value) {
+        this.value = value;
+        return this;
+    }
+    inline() {
+        this.isNewLine = false;
+        return this;
+    }
+    bold() {
+        if (this.clk)
+            this.clk = this.clk.bold;
+        else
+            this.clk = chalk.bold;
+        return this;
+    }
+    danger() {
+        if (this.clk)
+            this.clk = this.clk.red;
+        else
+            this.clk = chalk.red;
+        return this;
+    }
+    info() {
+        if (this.clk)
+            this.clk = this.clk.hex("#0CCAF0");
+        else
+            this.clk = chalk.hex("#0CCAF0");
+        return this;
+    }
+    line() {
+        console.log("-".repeat(process.stdout.columns));
+    }
+    show() {
+        return this.clk(this._value);
+    }
+    get _value() {
+        if (this.isNewLine)
+            return `${this.value}${os.EOL}`;
+        return this.value;
+    }
+}

package/dist/builders/EnumBuilder.d.ts

@@ -1,3 +1,7 @@
+export type EnumItem = {
+    name: string;
+    value: number;
+};
 export default class EnumBuilder {
     protected enums: any;
     constructor(enums: any);

package/dist/builders/ResponseBuilder.d.ts

@@ -0,0 +1,11 @@
+export default class ResponseBuilder {
+    protected data?: any;
+    protected message: string;
+    protected status: number;
+    constructor();
+    setData(data?: any): ResponseBuilder;
+    setMessage(message: string): ResponseBuilder;
+    setStatus(status: number): ResponseBuilder;
+    send(): globalThis.Response;
+    stream(options?: ResponseInit): globalThis.Response;
+}

package/dist/builders/ResponseBuilder.js

@@ -0,0 +1,41 @@
+import { cors } from "../utils/utils";
+export default class ResponseBuilder {
+    constructor() {
+        this.data = null;
+        this.message = "Success";
+        this.status = 200;
+    }
+    setData(data) {
+        this.data = data;
+        return this;
+    }
+    setMessage(message) {
+        this.message = message;
+        return this;
+    }
+    setStatus(status) {
+        this.status = status;
+        return this;
+    }
+    send() {
+        return globalThis.Response.json({
+            data: this.data,
+            message: this.message,
+            status: this.status
+        }, {
+            headers: {
+                ...cors()
+            },
+            status: this.status
+        });
+    }
+    stream(options = {}) {
+        return new globalThis.Response(Bun.file(this.data), {
+            ...options,
+            headers: {
+                ...cors()
+            },
+            status: this.status
+        });
+    }
+}

package/dist/builders/RouterBuilder.d.ts

@@ -0,0 +1,19 @@
+import type { IMiddleware } from "@/types/middleware";
+import type { HandlerType, ResourceAction, RouterGroup } from "@/types/router";
+import HttpMethodEnum from "../enums/HttpMethodEnum";
+export interface ResourceOptions {
+    only?: Array<ResourceAction>;
+    except?: Array<ResourceAction>;
+}
+export default class RouterBuilder {
+    private basePath;
+    private middlewares;
+    prefix(basePath: string): RouterBuilder;
+    middleware(...middlewares: Array<IMiddleware>): RouterBuilder;
+    group(routes: RouterGroup | Array<RouterGroup>): RouterGroup;
+    resources(controller: Record<string, HandlerType>, options?: ResourceOptions): RouterGroup;
+    buildSingle(method: HttpMethodEnum, path: string, handler: string | HandlerType): RouterGroup;
+    private joinPaths;
+    private resolveControllerString;
+    private resolveIncludedActions;
+}

package/dist/builders/RouterBuilder.js

@@ -0,0 +1,128 @@
+import RouterInvalidException from "../exceptions/RouterInvalidException";
+import { isEmpty } from "../utils/utils";
+import path from "path";
+export default class RouterBuilder {
+    constructor() {
+        this.basePath = "";
+        this.middlewares = [];
+    }
+    prefix(basePath) {
+        this.basePath = basePath;
+        return this;
+    }
+    middleware(...middlewares) {
+        this.middlewares.push(...middlewares);
+        return this;
+    }
+    group(routes) {
+        const routeList = Array.isArray(routes) ? routes : [routes];
+        const newRoutes = {};
+        for (const route of routeList) {
+            for (const path in route) {
+                const fullPath = this.joinPaths(this.basePath, path);
+                const routeHandlers = route[path];
+                const wrappedHandlers = {};
+                for (const method in routeHandlers) {
+                    let handler = routeHandlers[method];
+                    for (const middleware of this.middlewares) {
+                        handler = middleware.handle(handler);
+                    }
+                    wrappedHandlers[method] = handler;
+                }
+                if (isEmpty(newRoutes[fullPath]))
+                    newRoutes[fullPath] = {};
+                Object.assign(newRoutes[fullPath], wrappedHandlers);
+            }
+        }
+        return newRoutes;
+    }
+    resources(controller, options) {
+        const allRoutes = {
+            "": {
+                GET: "index",
+                POST: "store"
+            },
+            ":id": {
+                GET: "show",
+                PUT: "update",
+                DELETE: "destroy"
+            }
+        };
+        const includedActions = this.resolveIncludedActions(options);
+        const filteredRoutes = {};
+        for (const path in allRoutes) {
+            const methods = allRoutes[path];
+            const methodHandlers = {};
+            for (const method in methods) {
+                const action = methods[method];
+                if (includedActions.has(action) && controller[action]) {
+                    methodHandlers[method] = controller[action];
+                }
+            }
+            if (Object.keys(methodHandlers).length > 0) {
+                filteredRoutes[path] = methodHandlers;
+            }
+        }
+        return this.group(filteredRoutes);
+    }
+    buildSingle(method, path, handler) {
+        const cleanPath = this.joinPaths(this.basePath, path);
+        let resolvedHandler = typeof handler === "string" ?
+            this.resolveControllerString(handler) :
+            handler;
+        for (const middleware of this.middlewares) {
+            resolvedHandler = middleware.handle(resolvedHandler);
+        }
+        return {
+            [cleanPath]: {
+                [method]: resolvedHandler
+            }
+        };
+    }
+    joinPaths(base, path) {
+        base = base.replace(/\/+$/, "");
+        path = path.replace(/^\/+/, "");
+        return "/" + [base, path].filter(Boolean).join("/");
+    }
+    resolveControllerString(definition) {
+        const [controllerName, methodName] = definition.split("@");
+        if (isEmpty(controllerName) || isEmpty(methodName)) {
+            throw new RouterInvalidException(`[RouterInvalidException]: Invalid router controller definition: ${definition}.`);
+        }
+        const controllerPath = path.resolve(process.cwd(), "app/controllers");
+        const location = `${controllerPath}/${controllerName}`;
+        let ControllerClass;
+        try {
+            ControllerClass = require(location).default;
+        }
+        catch {
+            return async (...args) => {
+                const module = await import(location);
+                const ESMController = module.default;
+                const instance = new ESMController();
+                if (typeof instance[methodName] !== "function") {
+                    throw new RouterInvalidException(`[RouterInvalidException]: Method "${methodName}" not found in ${controllerName}.`);
+                }
+                return instance[methodName](...args);
+            };
+        }
+        if (isEmpty(ControllerClass)) {
+            throw new RouterInvalidException(`[RouterInvalidException]: Controller not found: ${controllerName}.`);
+        }
+        const instance = new ControllerClass();
+        if (typeof instance[methodName] !== "function") {
+            throw new RouterInvalidException(`[RouterInvalidException]: Method "${methodName}" not found in ${controllerName}.`);
+        }
+        return instance[methodName].bind(instance);
+    }
+    resolveIncludedActions(options) {
+        const all = ["index", "store", "show", "update", "destroy"];
+        if (options?.only) {
+            return new Set(options.only);
+        }
+        if (options?.except) {
+            return new Set(all.filter(action => !options.except.includes(action)));
+        }
+        return new Set(all);
+    }
+}

package/dist/config/cors.d.ts

@@ -0,0 +1,2 @@
+declare const config: Record<string, any>;
+export default config;

package/dist/config/cors.js

@@ -0,0 +1,9 @@
+const config = {
+    allowedHeaders: "*",
+    credentials: false,
+    exposedHeaders: [],
+    maxAge: 86400,
+    methods: "*",
+    origin: "*"
+};
+export default config;

package/dist/config/database.d.ts

@@ -0,0 +1,3 @@
+import type { Knex } from "knex";
+declare const config: Knex.Config;
+export default config;

package/dist/config/database.js

@@ -0,0 +1,24 @@
+const config = {
+    client: "pg",
+    connection: {
+        host: "127.0.0.1",
+        port: 5432,
+        user: "postgres",
+        password: "",
+        database: "bejibun"
+    },
+    migrations: {
+        extension: "ts",
+        directory: "./database/migrations",
+        tableName: "migrations"
+    },
+    pool: {
+        min: 0,
+        max: 1
+    },
+    seeds: {
+        extension: "ts",
+        directory: "./database/seeders"
+    }
+};
+export default config;

package/dist/enums/CorsHeaderEnum.d.ts

@@ -0,0 +1,8 @@
+declare enum CorsHeaderEnum {
+    Accept = "Accept",
+    Authorization = "Authorization",
+    ContentType = "Content-Type",
+    Origin = "Origin",
+    XRequestedWith = "X-Requested-With"
+}
+export default CorsHeaderEnum;

package/dist/enums/CorsHeaderEnum.js

@@ -0,0 +1,9 @@
+var CorsHeaderEnum;
+(function (CorsHeaderEnum) {
+    CorsHeaderEnum["Accept"] = "Accept";
+    CorsHeaderEnum["Authorization"] = "Authorization";
+    CorsHeaderEnum["ContentType"] = "Content-Type";
+    CorsHeaderEnum["Origin"] = "Origin";
+    CorsHeaderEnum["XRequestedWith"] = "X-Requested-With";
+})(CorsHeaderEnum || (CorsHeaderEnum = {}));
+export default CorsHeaderEnum;

package/dist/enums/HttpMethodEnum.d.ts

@@ -0,0 +1,12 @@
+declare enum HttpMethodEnum {
+    Connect = "CONNECT",
+    Delete = "DELETE",
+    Get = "GET",
+    Head = "HEAD",
+    Options = "OPTIONS",
+    Patch = "PATCH",
+    Post = "POST",
+    Put = "PUT",
+    Trace = "TRACE"
+}
+export default HttpMethodEnum;

package/dist/enums/HttpMethodEnum.js

@@ -0,0 +1,13 @@
+var HttpMethodEnum;
+(function (HttpMethodEnum) {
+    HttpMethodEnum["Connect"] = "CONNECT";
+    HttpMethodEnum["Delete"] = "DELETE";
+    HttpMethodEnum["Get"] = "GET";
+    HttpMethodEnum["Head"] = "HEAD";
+    HttpMethodEnum["Options"] = "OPTIONS";
+    HttpMethodEnum["Patch"] = "PATCH";
+    HttpMethodEnum["Post"] = "POST";
+    HttpMethodEnum["Put"] = "PUT";
+    HttpMethodEnum["Trace"] = "TRACE";
+})(HttpMethodEnum || (HttpMethodEnum = {}));
+export default HttpMethodEnum;

package/dist/exceptions/ModelNotFoundException.d.ts

@@ -0,0 +1,4 @@
+export default class ModelNotFoundException extends Error {
+    code: number;
+    constructor(message?: string, code?: number);
+}

package/dist/exceptions/ModelNotFoundException.js

@@ -0,0 +1,11 @@
+import { defineValue } from "../utils/utils";
+export default class ModelNotFoundException extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = "ModelNotFoundException";
+        this.code = defineValue(code, 404);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ModelNotFoundException);
+        }
+    }
+}

package/dist/exceptions/RouterInvalidException.d.ts

@@ -0,0 +1,4 @@
+export default class RouterInvalidException extends Error {
+    code: number;
+    constructor(message?: string, code?: number);
+}

package/dist/exceptions/RouterInvalidException.js

@@ -0,0 +1,11 @@
+import { defineValue } from "../utils/utils";
+export default class RouterInvalidException extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = "RouterInvalidException";
+        this.code = defineValue(code, 500);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, RouterInvalidException);
+        }
+    }
+}

package/dist/exceptions/ValidatorException.d.ts

@@ -0,0 +1,4 @@
+export default class ValidatorException extends Error {
+    code: number;
+    constructor(message?: string, code?: number);
+}

package/dist/exceptions/ValidatorException.js

@@ -0,0 +1,11 @@
+import { defineValue } from "../utils/utils";
+export default class ValidatorException extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = "ValidatorException";
+        this.code = defineValue(code, 422);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ValidatorException);
+        }
+    }
+}

package/dist/facades/Chalk.d.ts

@@ -0,0 +1,4 @@
+import ChalkBuilder from "../builders/ChalkBuilder";
+export default class Chalk {
+    static setValue(value: string): ChalkBuilder;
+}

package/dist/facades/Chalk.js

@@ -0,0 +1,6 @@
+import ChalkBuilder from "../builders/ChalkBuilder";
+export default class Chalk {
+    static setValue(value) {
+        return new ChalkBuilder().setValue(value);
+    }
+}

package/dist/facades/Enum.d.ts

@@ -1,4 +1,6 @@
 import EnumBuilder from "../builders/EnumBuilder";
+import type { EnumItem } from "../builders/EnumBuilder";
+export type { EnumItem };
 export default class Enum {
     static setEnums(enums: any): EnumBuilder;
 }

package/dist/facades/Response.d.ts

@@ -0,0 +1,6 @@
+import ResponseBuilder from "../builders/ResponseBuilder";
+export default class Response {
+    static setData(data?: any): ResponseBuilder;
+    static setMessage(message: string): ResponseBuilder;
+    static setStatus(status: number): ResponseBuilder;
+}

package/dist/facades/Response.js

@@ -0,0 +1,12 @@
+import ResponseBuilder from "../builders/ResponseBuilder";
+export default class Response {
+    static setData(data) {
+        return new ResponseBuilder().setData(data);
+    }
+    static setMessage(message) {
+        return new ResponseBuilder().setMessage(message);
+    }
+    static setStatus(status) {
+        return new ResponseBuilder().setStatus(status);
+    }
+}

package/dist/facades/Router.d.ts

@@ -0,0 +1,21 @@
+import type { IMiddleware } from "@/types/middleware";
+import type { HandlerType, RouterGroup } from "@/types/router";
+import RouterBuilder, { ResourceOptions } from "../builders/RouterBuilder";
+import HttpMethodEnum from "../enums/HttpMethodEnum";
+export default class Router {
+    static prefix(basePath: string): RouterBuilder;
+    static middleware(...middlewares: Array<IMiddleware>): RouterBuilder;
+    static resources(controller: Record<string, HandlerType>, options?: ResourceOptions): RouterGroup;
+    static group(routes: RouterGroup, prefix?: string, middlewares?: Array<IMiddleware>): RouterGroup;
+    static connect(path: string, handler: string | HandlerType): RouterGroup;
+    static delete(path: string, handler: string | HandlerType): RouterGroup;
+    static get(path: string, handler: string | HandlerType): RouterGroup;
+    static head(path: string, handler: string | HandlerType): RouterGroup;
+    static options(path: string, handler: string | HandlerType): RouterGroup;
+    static patch(path: string, handler: string | HandlerType): RouterGroup;
+    static post(path: string, handler: string | HandlerType): RouterGroup;
+    static put(path: string, handler: string | HandlerType): RouterGroup;
+    static trace(path: string, handler: string | HandlerType): RouterGroup;
+    static match(methods: Array<HttpMethodEnum>, path: string, handler: string | HandlerType): RouterGroup;
+    static any(path: string, handler: string | HandlerType): RouterGroup;
+}

package/dist/facades/Router.js

@@ -0,0 +1,66 @@
+import RouterBuilder from "../builders/RouterBuilder";
+import HttpMethodEnum from "../enums/HttpMethodEnum";
+import Enum from "../facades/Enum";
+import { isEmpty } from "../utils/utils";
+export default class Router {
+    static prefix(basePath) {
+        return new RouterBuilder().prefix(basePath);
+    }
+    static middleware(...middlewares) {
+        return new RouterBuilder().middleware(...middlewares);
+    }
+    static resources(controller, options) {
+        return new RouterBuilder().resources(controller, options);
+    }
+    static group(routes, prefix, middlewares) {
+        const builder = new RouterBuilder();
+        if (prefix)
+            builder.prefix(prefix);
+        if (middlewares?.length)
+            builder.middleware(...middlewares);
+        return builder.group(routes);
+    }
+    static connect(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Connect, path, handler);
+    }
+    static delete(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Delete, path, handler);
+    }
+    static get(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Get, path, handler);
+    }
+    static head(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Head, path, handler);
+    }
+    static options(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Options, path, handler);
+    }
+    static patch(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Patch, path, handler);
+    }
+    static post(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Post, path, handler);
+    }
+    static put(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Put, path, handler);
+    }
+    static trace(path, handler) {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Trace, path, handler);
+    }
+    static match(methods, path, handler) {
+        const builder = new RouterBuilder();
+        const routeMap = {};
+        for (const method of methods) {
+            const single = builder.buildSingle(method, path, handler);
+            const fullPath = Object.keys(single)[0];
+            const handlers = single[fullPath];
+            if (isEmpty(routeMap[fullPath]))
+                routeMap[fullPath] = {};
+            Object.assign(routeMap[fullPath], handlers);
+        }
+        return routeMap;
+    }
+    static any(path, handler) {
+        return this.match(Enum.setEnums(HttpMethodEnum).toArray(), path, handler);
+    }
+}

package/dist/facades/SoftDeletes.d.ts

@@ -0,0 +1,11 @@
+import { QueryBuilder, ModelClass, Model } from "objection";
+export default class SoftDeletes<M extends Model, R = M[]> extends QueryBuilder<M, R> {
+    private hasFilterApplied;
+    constructor(modelClass: ModelClass<M>);
+    withTrashed(): this;
+    onlyTrashed(): this;
+    delete(): QueryBuilder<M, number>;
+    del(): QueryBuilder<M, number>;
+    forceDelete(): QueryBuilder<M, number>;
+    restore(): QueryBuilder<M, number>;
+}

package/dist/facades/SoftDeletes.js

@@ -0,0 +1,50 @@
+import { DateTime } from "luxon";
+import { QueryBuilder } from "objection";
+export default class SoftDeletes extends QueryBuilder {
+    constructor(modelClass) {
+        // @ts-ignore
+        super(modelClass);
+        this.hasFilterApplied = false;
+        this.onBuild((builder) => {
+            const context = this.context();
+            if (!this.hasFilterApplied) {
+                const tableName = this.modelClass().tableName;
+                if (context.onlyTrashed) {
+                    builder.whereNotNull(`${tableName}.${this.modelClass().deletedColumn}`);
+                }
+                else if (!context.withTrashed) {
+                    builder.whereNull(`${tableName}.${this.modelClass().deletedColumn}`);
+                }
+                this.hasFilterApplied = true;
+            }
+        });
+    }
+    withTrashed() {
+        return this.context({
+            ...this.context(),
+            withTrashed: true
+        });
+    }
+    onlyTrashed() {
+        return this.context({
+            ...this.context(),
+            onlyTrashed: true
+        });
+    }
+    delete() {
+        return this.update({
+            [this.modelClass().deletedColumn]: DateTime.now()
+        });
+    }
+    del() {
+        return this.delete();
+    }
+    forceDelete() {
+        return super.delete();
+    }
+    restore() {
+        return this.onlyTrashed().update({
+            [this.modelClass().deletedColumn]: null
+        });
+    }
+}

package/dist/index.d.ts

@@ -1,13 +1 @@
-import Enum from "./facades/Enum";
-import Str from "./facades/Str";
-export { Enum, Str };
 export * from "./utils/utils";
-declare const _default: {
-    isEmpty: (value: any) => boolean;
-    isNotEmpty: (value: any) => boolean;
-    defineValue: (value: any, defaultValue?: any) => any;
-    ask: (question: string) => Promise<string>;
-    Enum: typeof Enum;
-    Str: typeof Str;
-};
-export default _default;

package/dist/index.js

@@ -1,10 +1 @@
-import Enum from "./facades/Enum";
-import Str from "./facades/Str";
-import * as Utils from "./utils/utils";
-export { Enum, Str };
 export * from "./utils/utils";
-export default {
-    Enum,
-    Str,
-    ...Utils,
-};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "@/types/middleware";
+export * from "@/types/router";

package/dist/types/middleware.d.ts

@@ -0,0 +1,7 @@
+import type {HandlerType} from "@/types/router";
+
+export type MiddlewareType = (handler: HandlerType) => HandlerType;
+
+export interface IMiddleware {
+    handle(handler: HandlerType): HandlerType;
+}

package/dist/types/router.d.ts

@@ -0,0 +1,5 @@
+import {BunRequest} from "bun";
+
+export type HandlerType = (request: BunRequest) => Promise<Response>;
+export type RouterGroup = Record<string, Record<string, HandlerType>>;
+export type ResourceAction = "index" | "store" | "show" | "update" | "destroy";

package/dist/types/validator.d.ts

@@ -0,0 +1,3 @@
+import {SchemaTypes, VineValidator} from "@vinejs/vine";
+
+export type ValidatorType<T extends SchemaTypes = SchemaTypes> = VineValidator<SchemaTypes, Record<string, any> | undefined>;

package/dist/types/vine.d.ts

@@ -0,0 +1,13 @@
+declare module "@vinejs/vine" {
+    interface VineNumber {
+        exists(tableOrOptions: string | { table: string; column?: string }, column?: string): this;
+        unique(tableOrOptions: string | { table: string; column?: string }, column?: string): this;
+    }
+
+    interface VineString {
+        exists(tableOrOptions: string | { table: string; column?: string }, column?: string): this;
+        unique(tableOrOptions: string | { table: string; column?: string }, column?: string): this;
+    }
+}
+
+export {};

package/dist/utils/utils.d.ts

@@ -2,3 +2,4 @@ export declare const isEmpty: (value: any) => boolean;
 export declare const isNotEmpty: (value: any) => boolean;
 export declare const defineValue: (value: any, defaultValue?: any) => any;
 export declare const ask: (question: string) => Promise<string>;
+export declare const cors: () => Record<string, string>;

package/dist/utils/utils.js

@@ -1,4 +1,9 @@
+import fs from "fs";
+import path from "path";
 import readline from "readline";
+import CorsHeaderEnum from "../enums/CorsHeaderEnum";
+import HttpMethodEnum from "../enums/HttpMethodEnum";
+import Enum from "../facades/Enum";
 export const isEmpty = (value) => {
     return (value === undefined ||
         value === null ||
@@ -22,10 +27,34 @@ export const ask = (question) => {
         input: process.stdin,
         output: process.stdout
     });
-    return new Promise((resolve, reject) => {
+    return new Promise(resolve => {
         return rl.question(question, (answer) => {
             rl.close();
             resolve(answer.trim());
         });
     });
 };
+export const cors = () => {
+    const configPath = path.resolve(process.cwd(), "config/cors.ts");
+    let corsConfig;
+    if (fs.existsSync(configPath))
+        corsConfig = require(configPath).default;
+    else
+        corsConfig = require("../config/cors").default;
+    const headers = {
+        "Access-Control-Allow-Origin": corsConfig.origin,
+        "Access-Control-Allow-Headers": Array.isArray(corsConfig.allowedHeaders)
+            ? corsConfig.allowedHeaders.join(", ")
+            : Enum.setEnums(CorsHeaderEnum).toArray().map((value) => value.value).join(", "),
+        "Access-Control-Allow-Methods": Array.isArray(corsConfig.methods)
+            ? corsConfig.methods.join(", ")
+            : Enum.setEnums(HttpMethodEnum).toArray().map((value) => value.value).join(", ")
+    };
+    if (corsConfig.exposedHeaders.length > 0)
+        headers["Access-Control-Expose-Headers"] = corsConfig.exposedHeaders.join(", ");
+    if (corsConfig.credentials)
+        headers["Access-Control-Allow-Credentials"] = "true";
+    if (corsConfig.maxAge)
+        headers["Access-Control-Max-Age"] = corsConfig.maxAge.toString();
+    return headers;
+};

package/dist/utils/vine.d.ts

@@ -0,0 +1,2 @@
+import "../utils/vines/exists";
+import "../utils/vines/unique";

package/dist/utils/vine.js

@@ -0,0 +1,2 @@
+import "../utils/vines/exists";
+import "../utils/vines/unique";

package/dist/utils/vines/exists.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/vines/exists.js

@@ -0,0 +1,28 @@
+import vine, { VineNumber, VineString } from "@vinejs/vine";
+import BaseModel from "../../bases/BaseModel";
+import { defineValue, isEmpty } from "../../utils/utils";
+const exists = async (value, options, field) => {
+    if (!field.isValid)
+        return;
+    const column = defineValue(options.column, field.name);
+    let query = options.table;
+    if (options.withTrashed)
+        query = query.withTrashed();
+    else
+        query = query.query();
+    const row = await query.where(column, value).first();
+    if (isEmpty(row))
+        field.report("The {{ field }} field doesn't exists", "exists", field);
+};
+const existsRule = vine.createRule(exists, { isAsync: true });
+const registerExistsMacro = (Type) => {
+    Type.macro("exists", function (tableOrOptions, column, withTrashed) {
+        const isModel = typeof tableOrOptions === "function" && Object.prototype.isPrototypeOf.call(BaseModel, tableOrOptions);
+        const options = isModel
+            ? { table: tableOrOptions, column, withTrashed }
+            : tableOrOptions;
+        return this.use(existsRule(options));
+    });
+};
+registerExistsMacro(VineString);
+registerExistsMacro(VineNumber);

package/dist/utils/vines/unique.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/vines/unique.js

@@ -0,0 +1,28 @@
+import vine, { VineNumber, VineString } from "@vinejs/vine";
+import BaseModel from "../../bases/BaseModel";
+import { defineValue, isNotEmpty } from "../../utils/utils";
+const unique = async (value, options, field) => {
+    if (!field.isValid)
+        return;
+    const column = defineValue(options.column, field.name);
+    let query = options.table;
+    if (options.withTrashed)
+        query = query.withTrashed();
+    else
+        query = query.query();
+    const row = await query.where(column, value).first();
+    if (isNotEmpty(row))
+        field.report("The {{ field }} field is already exists", "unique", field);
+};
+const uniqueRule = vine.createRule(unique, { isAsync: true });
+const registerUniqueMacro = (Type) => {
+    Type.macro("unique", function (tableOrOptions, column, withTrashed) {
+        const isModel = typeof tableOrOptions === "function" && Object.prototype.isPrototypeOf.call(BaseModel, tableOrOptions);
+        const options = isModel
+            ? { table: tableOrOptions, column, withTrashed }
+            : tableOrOptions;
+        return this.use(uniqueRule(options));
+    });
+};
+registerUniqueMacro(VineString);
+registerUniqueMacro(VineNumber);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bejibun/core",
-    "version": "0.1.21",
+    "version": "0.1.22",
     "description": "Core of Bejibun Framework",
     "keywords": [
         "bun",
@@ -22,19 +22,35 @@
     "type": "module",
     "main": "./dist/index.js",
     "module": "./dist/index.js",
-    "types": "./dist/index.d.ts",
+    "types": "./types/index.d.ts",
     "exports": {
         ".": {
             "import": "./dist/index.js",
             "types": "./dist/index.d.ts"
         },
-        "./enum": {
-            "import": "./dist/facades/Enum.js",
-            "types": "./dist/facades/Enum.d.ts"
+        "./bootstrap": {
+            "import": "./dist/bootstrap.js",
+            "types": "./dist/bootstrap.d.ts"
         },
-        "./str": {
-            "import": "./dist/facades/Str.js",
-            "types": "./dist/facades/Str.d.ts"
+        "./bases/*": {
+            "import": "./dist/bases/*.js",
+            "types": "./dist/bases/*.d.ts"
+        },
+        "./enums/*": {
+            "import": "./dist/enums/*.js",
+            "types": "./dist/enums/*.d.ts"
+        },
+        "./exceptions/*": {
+            "import": "./dist/exceptions/*.js",
+            "types": "./dist/exceptions/*.d.ts"
+        },
+        "./facades/*": {
+            "import": "./dist/facades/*.js",
+            "types": "./dist/facades/*.d.ts"
+        },
+        "./types/*": {
+            "import": "./dist/types/*.js",
+            "types": "./dist/types/*.d.ts"
         }
     },
     "files": [
@@ -42,11 +58,20 @@
     ],
     "scripts": {
         "clean": "rm -rf dist",
-        "build": "bun run clean && tsc -p tsconfig.json && tsc-alias -p tsconfig.json"
+        "build": "bun run clean && tsc -p tsconfig.json && tsc-alias -p tsconfig.json && cp -rf src/types dist/types",
+        "publish": "bun run build && npm publish --access public"
+    },
+    "dependencies": {
+        "@vinejs/vine": "^3.0.1",
+        "chalk": "^5.6.2",
+        "knex": "^3.1.0",
+        "luxon": "^3.7.2",
+        "objection": "^3.1.5",
+        "pg": "^8.16.3"
     },
-    "dependencies": {},
     "devDependencies": {
         "@types/bun": "latest",
+        "@types/luxon": "^3.7.1",
         "tsc-alias": "^1.8.16",
         "typescript": "^5.9.3"
     },