@bejibun/core 0.1.39 → 0.1.40

package/src/bases/BaseController.ts

@@ -1,139 +0,0 @@
-import {defineValue, isEmpty, isNotEmpty} from "@bejibun/utils";
-import {errors, VineValidator} from "@vinejs/vine";
-import {BunRequest} from "bun";
-import {DateTime} from "luxon";
-import ValidatorException from "@/exceptions/ValidatorException";
-import Response from "@/facades/Response";
-
-export default class BaseController {
-    public async parse(request: BunRequest): Promise<Record<string, any>> {
-        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 as string);
-            }
-
-            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);
-    }
-
-    public get response(): typeof Response {
-        return Response;
-    }
-
-    public async validate(validator: VineValidator<any, Record<string, any> | undefined>, body: Record<string, any>): Promise<any> {
-        try {
-            return await validator.validate(body);
-        } catch (error: typeof errors.E_VALIDATION_ERROR | any) {
-            throw new ValidatorException(error.messages[0].message);
-        }
-    }
-
-    private serialize(data: any): any {
-        if (Array.isArray(data)) return data.map((value: any) => 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: Record<string, any> = {};
-            Object.keys(data).forEach((key: string) => {
-                nested[key] = this.serialize(data[key]);
-            });
-
-            return nested;
-        }
-
-        if (typeof data === "string") {
-            const trimmed: string = 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;
-    }
-
-    private parseForm(formData: FormData): Record<string, any> {
-        const result: Record<string, any> = {};
-
-        for (const [key, value] of formData.entries()) {
-            const keys = key.replace(/]/g, "").split("[");
-
-            let current: any = 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: any;
-
-                    if (value as unknown 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/src/bases/BaseModel.ts

@@ -1,108 +0,0 @@
-import type {Knex} from "knex";
-import {defineValue, isEmpty} from "@bejibun/utils";
-import Str from "@bejibun/utils/facades/Str";
-import {DateTime} from "luxon";
-import {
-    Constructor,
-    Model,
-    ModelOptions,
-    PartialModelObject,
-    QueryBuilder,
-    QueryBuilderType,
-    QueryContext,
-    TransactionOrKnex
-} from "objection";
-import {relative, sep} from "path";
-import {fileURLToPath} from "url";
-import ModelNotFoundException from "@/exceptions/ModelNotFoundException";
-import SoftDeletes from "@/facades/SoftDeletes";
-
-export interface BaseColumns {
-    id: bigint | number;
-    created_at: DateTime | string;
-    updated_at: DateTime | string;
-    deleted_at: DateTime | string | null;
-}
-
-class BunQueryBuilder<M extends Model, R = M[]> extends SoftDeletes<M, R> {
-    // @ts-ignore
-    async update(payload: PartialModelObject<M>): Promise<QueryBuilder<M, R>> {
-        const cloneQuery: QueryBuilder<M, R> = (this as any).clone();
-
-        const beforeRows: any = await cloneQuery;
-
-        if (isEmpty(beforeRows)) return defineValue(beforeRows);
-
-        await super.update(payload);
-
-        return cloneQuery;
-    }
-}
-
-// @ts-ignore
-export default class BaseModel extends Model implements BaseColumns {
-    public static tableName: string;
-    public static idColumn: string;
-    public static deletedColumn: string = "deleted_at";
-
-    public static QueryBuilder = BunQueryBuilder;
-
-    declare id: number | bigint;
-    declare created_at: DateTime | string;
-    declare updated_at: DateTime | string;
-    declare deleted_at: DateTime | string | null;
-
-    public static get namespace(): string {
-        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: QueryContext): void {
-        const now = DateTime.now();
-        this.created_at = now;
-        this.updated_at = now;
-    }
-
-    $beforeUpdate(opt: ModelOptions, queryContext: QueryContext): void {
-        this.updated_at = DateTime.now();
-    }
-
-    public static query<T extends Model>(this: Constructor<T>, trxOrKnex?: TransactionOrKnex): QueryBuilderType<T> {
-        return super.query(trxOrKnex);
-    };
-
-    public static withTrashed<T extends Model>(this: T): QueryBuilderType<T> {
-        return (this as any).query().withTrashed();
-    }
-
-    public static onlyTrashed<T extends Model>(this: T): QueryBuilderType<T> {
-        return (this as any).query().onlyTrashed();
-    }
-
-    public static all<T extends Model>(this: T): QueryBuilderType<T> {
-        return (this as any).query().select();
-    }
-
-    public static create<T extends Model>(this: T, payload: Record<string, any>): QueryBuilderType<T> {
-        return (this as any).query().insert(payload);
-    }
-
-    public static find<T extends Model>(this: T, id: bigint | number | string): QueryBuilderType<T> {
-        return (this as any).query().findById(id);
-    }
-
-    public static async findOrFail<T extends Model>(this: T, id: bigint | number | string): Promise<T> {
-        const result = await (this as any).find(id);
-
-        if (isEmpty(result)) throw new ModelNotFoundException(`[ModelNotFoundException]: No query results for model [${(this as any).namespace}] [${id}].`);
-
-        return result;
-    }
-}

package/src/bases/BaseValidator.ts

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

package/src/bases/index.ts

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

package/src/bootstrap.ts

@@ -1,5 +0,0 @@
-import {Model} from "objection";
-import BaseModel from "@/bases/BaseModel";
-import {initDatabase} from "@/config/database";
-
-(BaseModel as any as typeof Model).knex(initDatabase());

package/src/builders/ResponseBuilder.ts

@@ -1,54 +0,0 @@
-import Cors from "@bejibun/cors";
-
-export default class ResponseBuilder {
-    protected data?: any;
-    protected message: string;
-    protected status: number;
-
-    public constructor() {
-        this.data = null;
-        this.message = "Success";
-        this.status = 200;
-    }
-
-    public setData(data?: any): ResponseBuilder {
-        this.data = data;
-
-        return this;
-    }
-
-    public setMessage(message: string): ResponseBuilder {
-        this.message = message;
-
-        return this;
-    }
-
-    public setStatus(status: number): ResponseBuilder {
-        this.status = status;
-
-        return this;
-    }
-
-    public send(): globalThis.Response {
-        return globalThis.Response.json({
-            data: this.data,
-            message: this.message,
-            status: this.status
-        }, {
-            headers: {
-                ...Cors.init
-            },
-            status: this.status
-        });
-    }
-
-    public stream(options: ResponseInit = {}): globalThis.Response {
-        return new globalThis.Response(Bun.file(this.data), {
-            ...options,
-            headers: {
-                ...Cors.init
-            },
-            status: this.status
-        });
-    }
-}

package/src/builders/RouterBuilder.ts

@@ -1,173 +0,0 @@
-import {isEmpty} from "@bejibun/utils";
-import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
-import path from "path";
-import type {IMiddleware} from "@/types/middleware";
-import type {HandlerType, ResourceAction, RouterGroup} from "@/types/router";
-import RouterInvalidException from "@/exceptions/RouterInvalidException";
-
-export interface ResourceOptions {
-    only?: Array<ResourceAction>;
-    except?: Array<ResourceAction>;
-}
-
-export default class RouterBuilder {
-    private basePath: string = "";
-    private middlewares: Array<IMiddleware> = [];
-
-    public prefix(basePath: string): RouterBuilder {
-        this.basePath = basePath;
-
-        return this;
-    }
-
-    public middleware(...middlewares: Array<IMiddleware>): RouterBuilder {
-        this.middlewares.push(...middlewares);
-
-        return this;
-    }
-
-    public group(routes: RouterGroup | Array<RouterGroup>): RouterGroup {
-        const routeList = Array.isArray(routes) ? routes : [routes];
-        const newRoutes: RouterGroup = {};
-
-        for (const route of routeList) {
-            for (const path in route) {
-                const fullPath = this.joinPaths(this.basePath, path);
-                const routeHandlers = route[path];
-                const wrappedHandlers: Record<string, HandlerType> = {};
-
-                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;
-    }
-
-    public resources(controller: Record<string, HandlerType>, options?: ResourceOptions): RouterGroup {
-        const allRoutes: Record<string, Record<string, ResourceAction>> = {
-            "": {
-                GET: "index",
-                POST: "store"
-            },
-            ":id": {
-                GET: "show",
-                PUT: "update",
-                DELETE: "destroy"
-            }
-        };
-
-        const includedActions = this.resolveIncludedActions(options);
-
-        const filteredRoutes: RouterGroup = {};
-
-        for (const path in allRoutes) {
-            const methods = allRoutes[path];
-            const methodHandlers: Record<string, HandlerType> = {};
-
-            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);
-    }
-
-    public buildSingle(method: HttpMethodEnum, path: string, handler: string | HandlerType): RouterGroup {
-        const cleanPath = this.joinPaths(this.basePath, path);
-
-        let resolvedHandler: HandlerType = typeof handler === "string" ?
-            this.resolveControllerString(handler) :
-            handler;
-
-        for (const middleware of this.middlewares) {
-            resolvedHandler = middleware.handle(resolvedHandler);
-        }
-
-        return {
-            [cleanPath]: {
-                [method]: resolvedHandler
-            }
-        };
-    }
-
-    private joinPaths(base: string, path: string): string {
-        base = base.replace(/\/+$/, "");
-        path = path.replace(/^\/+/, "");
-
-        return "/" + [base, path].filter(Boolean).join("/");
-    }
-
-    private resolveControllerString(definition: string): HandlerType {
-        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: any;
-
-        try {
-            ControllerClass = require(location).default;
-        } catch {
-            return async (...args: any[]) => {
-                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);
-    }
-
-    private resolveIncludedActions(options?: ResourceOptions): Set<ResourceAction> {
-        const all: Array<ResourceAction> = ["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/src/commands/DbSeedCommand.ts

@@ -1,57 +0,0 @@
-import Chalk from "@bejibun/logger/facades/Chalk";
-import ora from "ora";
-import path from "path";
-import {initDatabase} from "@/config/database";
-
-export default class DbSeedCommand {
-    /**
-     * The name and signature of the console command.
-     *
-     * @var $signature string
-     */
-    protected $signature: string = "db:seed";
-
-    /**
-     * The console command description.
-     *
-     * @var $description string
-     */
-    protected $description: string = "Run database seeders";
-
-    /**
-     * The options or optional flag of the console command.
-     *
-     * @var $options Array<Array<string>>
-     */
-    protected $options: Array<Array<string>> = [];
-
-    /**
-     * The arguments of the console command.
-     *
-     * @var $arguments Array<Array<string>>
-     */
-    protected $arguments: Array<Array<string>> = [];
-
-    public async handle(options: any, args: Array<string>): Promise<void> {
-        const database = initDatabase();
-
-        const spinner = ora(
-            Chalk.setValue("Seeding...")
-                .info()
-                .show()
-        ).start();
-
-        try {
-            const logs = (await database.seed.run()).flat();
-            spinner.succeed("Seeding finished");
-
-            if (logs.length > 0) logs.forEach((seeder: string) => spinner.succeed(path.basename(seeder)));
-            else spinner.succeed("No seeders were run.");
-        } catch (error: any) {
-            spinner.fail(`Seeding failed : ${error.message}`);
-        } finally {
-            await database.destroy();
-            spinner.stop();
-        }
-    }
-}

package/src/commands/Kernel.ts

@@ -1,49 +0,0 @@
-import type {Command} from "commander";
-import {defineValue, isEmpty} from "@bejibun/utils";
-import {readdirSync} from "fs";
-import path from "path";
-
-export default class Kernel {
-    public static registerCommands(program: Command): void {
-        const commandsDir = path.resolve(__dirname);
-        const files = readdirSync(commandsDir).filter((file: string) => {
-            return (
-                /\.(m?js|ts)$/.test(file) &&
-                !file.endsWith(".d.ts") &&
-                !file.includes("Kernel")
-            )
-        });
-
-        for (const file of files) {
-            const modulePath = path.join(commandsDir, file);
-            const {default: CommandClass} = require(modulePath);
-
-            const instance = new CommandClass();
-
-            if (isEmpty(instance.$signature) || typeof instance.handle !== "function") continue;
-
-            const cmd = program
-                .command(instance.$signature)
-                .description(defineValue(instance.$description, ""))
-                .action(instance.handle);
-
-            if (Array.isArray(instance.$options)) {
-                for (const option of instance.$options) {
-                    cmd.option(...(option as [string, string?, any?]));
-                }
-            }
-
-            if (Array.isArray(instance.$arguments)) {
-                for (const argument of instance.$arguments) {
-                    cmd.argument(...(argument as [string, string?, unknown?]));
-                }
-            }
-
-            cmd.action(async (...args: any[]) => {
-                const lastArg = args[args.length - 1];
-                const options = defineValue(lastArg, {});
-                await instance.handle(options, args.slice(0, -1));
-            });
-        }
-    }
-}

package/src/commands/MigrateFreshCommand.ts

@@ -1,76 +0,0 @@
-import Chalk from "@bejibun/logger/facades/Chalk";
-import {ask, isNotEmpty} from "@bejibun/utils";
-import ora from "ora";
-import {initDatabase} from "@/config/database";
-
-export default class MigrateFreshCommand {
-    /**
-     * The name and signature of the console command.
-     *
-     * @var $signature string
-     */
-    protected $signature: string = "migrate:fresh";
-
-    /**
-     * The console command description.
-     *
-     * @var $description string
-     */
-    protected $description: string = "Rollback all migrations and re-run migrations";
-
-    /**
-     * The options or optional flag of the console command.
-     *
-     * @var $options Array<Array<string>>
-     */
-    protected $options: Array<Array<string>> = [
-        ["-f, --force", "Skip command confirmation."]
-    ];
-
-    /**
-     * The arguments of the console command.
-     *
-     * @var $arguments Array<Array<string>>
-     */
-    protected $arguments: Array<Array<string>> = [];
-
-    public async handle(options: any, args: Array<string>): Promise<void> {
-        const database = initDatabase();
-
-        const bypass = isNotEmpty(options.force);
-
-        let confirm = "Y";
-        if (!bypass) confirm = await ask(
-            Chalk.setValue("This will DROP ALL tables and re-run ALL migrations. Are you want to continue? (Y/N): ")
-                .inline()
-                .error()
-                .show()
-        );
-
-        if (confirm.toUpperCase() === "Y") {
-            if (!bypass) console.log();
-
-            const spinner = ora(
-                Chalk.setValue("Rollback...")
-                    .info()
-                    .show()
-            ).start();
-
-            try {
-                await database.migrate.rollback({}, true);
-                spinner.succeed("Rolled back all migrations");
-
-                const [batchNo, logs] = await database.migrate.latest();
-                spinner.succeed(`Batch ${batchNo} finished`);
-
-                if (logs.length > 0) logs.forEach((migration: string) => spinner.succeed(migration));
-                else spinner.succeed("No migrations were run.");
-            } catch (error: any) {
-                spinner.fail(`Migration failed : ${error.message}`);
-            } finally {
-                await database.destroy();
-                spinner.stop();
-            }
-        }
-    }
-}