@bejibun/core 0.1.29 → 0.1.31

package/src/bases/BaseValidator.ts

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

package/src/bootstrap.ts

@@ -0,0 +1,13 @@
+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: any;
+
+if (fs.existsSync(configPath)) config = require(configPath).default;
+else config = require("@/config/database").default;
+
+BaseModel.knex(knex(config));

package/src/builders/ChalkBuilder.ts

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

package/src/builders/EnumBuilder.ts

@@ -0,0 +1,32 @@
+import {isEmpty} from "@/utils/utils";
+
+export type EnumItem = {
+    name: string;
+    value: number;
+}
+
+export default class EnumBuilder {
+    protected enums: any;
+
+    public constructor(enums: any) {
+        if (isEmpty(enums)) throw new Error("The enum parameter is required.");
+        this.enums = enums;
+    }
+
+    public getName(value: number): string | undefined {
+        return Object.keys(this.enums).find(item => this.enums[item] === value);
+    }
+
+    public getValue(key: string): number {
+        return this.enums[key];
+    }
+
+    public toArray(): Array<any> {
+        return Object.keys(this.enums)
+            .filter(key => isNaN(Number(key)))
+            .map(key => ({
+                name: key,
+                value: this.getValue(key)
+            }));
+    }
+}

package/src/builders/ResponseBuilder.ts

@@ -0,0 +1,54 @@
+import {cors} from "@/utils/utils";
+
+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()
+            },
+            status: this.status
+        });
+    }
+
+    public stream(options: ResponseInit = {}): globalThis.Response {
+        return new globalThis.Response(Bun.file(this.data), {
+            ...options,
+            headers: {
+                ...cors()
+            },
+            status: this.status
+        });
+    }
+}

package/src/builders/RouterBuilder.ts

@@ -0,0 +1,173 @@
+import type {IMiddleware} from "@/types/middleware";
+import type {HandlerType, ResourceAction, RouterGroup} from "@/types/router";
+import HttpMethodEnum from "@/enums/HttpMethodEnum";
+import RouterInvalidException from "@/exceptions/RouterInvalidException";
+import {isEmpty} from "@/utils/utils";
+import path from "path";
+
+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/builders/StrBuilder.ts

@@ -0,0 +1,25 @@
+import {defineValue, isNotEmpty} from "@/utils/utils";
+
+export default class StrBuilder {
+    protected value: string;
+
+    public constructor() {
+        this.value = "";
+    }
+
+    public setValue(value: string): StrBuilder {
+        this.value = value;
+
+        return this;
+    }
+
+    public toPascalCase(combine?: boolean): StrBuilder | string {
+        this.value = defineValue(this.value.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g), [])
+            .map((x: string) => x.slice(0, 1).toUpperCase() + x.slice(1).toLowerCase())
+            .join("");
+
+        if (isNotEmpty(combine)) return this;
+
+        return this.value;
+    }
+}

package/src/config/cors.ts

@@ -0,0 +1,10 @@
+const config: Record<string, any> = {
+    allowedHeaders: "*",
+    credentials: false,
+    exposedHeaders: [],
+    maxAge: 86400,
+    methods: "*",
+    origin: "*"
+};
+
+export default config;

package/src/config/database.ts

@@ -0,0 +1,27 @@
+import type {Knex} from "knex";
+
+const config: Knex.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/src/enums/CorsHeaderEnum.ts

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

package/src/enums/HttpMethodEnum.ts

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

package/src/exceptions/ModelNotFoundException.ts

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

package/src/exceptions/RouterInvalidException.ts

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

package/src/exceptions/ValidatorException.ts

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

package/src/facades/Chalk.ts

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

package/src/facades/Enum.ts

@@ -0,0 +1,10 @@
+import EnumBuilder from "@/builders/EnumBuilder";
+import type {EnumItem} from "@/builders/EnumBuilder";
+
+export type {EnumItem};
+
+export default class Enum {
+    public static setEnums(enums: any): EnumBuilder {
+        return new EnumBuilder(enums);
+    }
+}

package/src/facades/Response.ts

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

package/src/facades/Router.ts

@@ -0,0 +1,89 @@
+import type {IMiddleware} from "@/types/middleware";
+import type {HandlerType, RouterGroup} from "@/types/router";
+import RouterBuilder, {ResourceOptions} from "@/builders/RouterBuilder";
+import HttpMethodEnum from "@/enums/HttpMethodEnum";
+import Enum from "@/facades/Enum";
+import {isEmpty} from "@/utils/utils";
+
+export default class Router {
+    public static prefix(basePath: string): RouterBuilder {
+        return new RouterBuilder().prefix(basePath);
+    }
+
+    public static middleware(...middlewares: Array<IMiddleware>): RouterBuilder {
+        return new RouterBuilder().middleware(...middlewares);
+    }
+
+    public static resources(
+        controller: Record<string, HandlerType>,
+        options?: ResourceOptions
+    ): RouterGroup {
+        return new RouterBuilder().resources(controller, options);
+    }
+
+    public static group(routes: RouterGroup, prefix?: string, middlewares?: Array<IMiddleware>) {
+        const builder = new RouterBuilder();
+
+        if (prefix) builder.prefix(prefix);
+        if (middlewares?.length) builder.middleware(...middlewares);
+
+        return builder.group(routes);
+    }
+
+    public static connect(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Connect, path, handler);
+    }
+
+    public static delete(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Delete, path, handler);
+    }
+
+    public static get(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Get, path, handler);
+    }
+
+    public static head(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Head, path, handler);
+    }
+
+    public static options(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Options, path, handler);
+    }
+
+    public static patch(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Patch, path, handler);
+    }
+
+    public static post(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Post, path, handler);
+    }
+
+    public static put(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Put, path, handler);
+    }
+
+    public static trace(path: string, handler: string | HandlerType): RouterGroup {
+        return new RouterBuilder().buildSingle(HttpMethodEnum.Trace, path, handler);
+    }
+
+    public static match(methods: Array<HttpMethodEnum>, path: string, handler: string | HandlerType): RouterGroup {
+        const builder = new RouterBuilder();
+        const routeMap: RouterGroup = {};
+
+        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;
+    }
+
+    public static any(path: string, handler: string | HandlerType): RouterGroup {
+        return this.match(Enum.setEnums(HttpMethodEnum).toArray(), path, handler);
+    }
+}

package/src/facades/SoftDeletes.ts

@@ -0,0 +1,66 @@
+import {DateTime} from "luxon";
+import {QueryBuilder, ModelClass, QueryContext, Model} from "objection";
+
+interface SoftDeleteQueryContext extends QueryContext {
+    withTrashed?: boolean;
+    onlyTrashed?: boolean;
+}
+
+export default class SoftDeletes<M extends Model, R = M[]> extends QueryBuilder<M, R> {
+    private hasFilterApplied = false;
+
+    constructor(modelClass: ModelClass<M>) {
+        // @ts-ignore
+        super(modelClass);
+
+        this.onBuild((builder: QueryBuilder<M, R>) => {
+            const context = this.context() as SoftDeleteQueryContext;
+
+            if (!this.hasFilterApplied) {
+                const tableName = this.modelClass().tableName;
+
+                if (context.onlyTrashed) {
+                    builder.whereNotNull(`${tableName}.${(this.modelClass() as any).deletedColumn}`);
+                } else if (!context.withTrashed) {
+                    builder.whereNull(`${tableName}.${(this.modelClass() as any).deletedColumn}`);
+                }
+
+                this.hasFilterApplied = true;
+            }
+        });
+    }
+
+    withTrashed(): this {
+        return (this as any).context({
+            ...(this as any).context(),
+            withTrashed: true
+        });
+    }
+
+    onlyTrashed(): this {
+        return (this as any).context({
+            ...(this as any).context(),
+            onlyTrashed: true
+        });
+    }
+
+    delete(): QueryBuilder<M, number> {
+        return this.update({
+            [(this.modelClass() as any).deletedColumn]: DateTime.now()
+        } as any);
+    }
+
+    del(): QueryBuilder<M, number> {
+        return this.delete();
+    }
+
+    forceDelete(): QueryBuilder<M, number> {
+        return super.delete();
+    }
+
+    restore(): QueryBuilder<M, number> {
+        return this.onlyTrashed().update({
+            [(this.modelClass() as any).deletedColumn]: null
+        } as any);
+    }
+}

package/src/facades/Str.ts

@@ -0,0 +1,7 @@
+import StrBuilder from "@/builders/StrBuilder";
+
+export default class Str {
+    public static toPascalCase(value: string, combine?: boolean): StrBuilder | string {
+        return new StrBuilder().setValue(value).toPascalCase(combine);
+    }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "@/utils/utils";