@bejibun/core 0.1.39 → 0.1.41

package/src/exceptions/index.ts

@@ -1,3 +0,0 @@
-export * from "@/exceptions/ModelNotFoundException";
-export * from "@/exceptions/RouterInvalidException";
-export * from "@/exceptions/ValidatorException";

package/src/facades/Response.ts

@@ -1,15 +0,0 @@
-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

@@ -1,89 +0,0 @@
-import type {IMiddleware} from "@/types/middleware";
-import type {HandlerType, RouterGroup} from "@/types/router";
-import {isEmpty} from "@bejibun/utils";
-import HttpMethodEnum from "@bejibun/utils/enums/HttpMethodEnum";
-import Enum from "@bejibun/utils/facades/Enum";
-import RouterBuilder, {ResourceOptions} from "@/builders/RouterBuilder";
-
-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

@@ -1,66 +0,0 @@
-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/index.ts

@@ -1,3 +0,0 @@
-export * from "@/facades/Response";
-export * from "@/facades/Router";
-export * from "@/facades/SoftDeletes";

package/src/index.ts

@@ -1,5 +0,0 @@
-export * from "@/bases/index";
-
-export * from "@/exceptions/index";
-
-export * from "@/facades/index";

package/src/types/index.d.ts

@@ -1,4 +0,0 @@
-export * from "@/types/middleware";
-export * from "@/types/router";
-export * from "@/types/validator";
-export * from "@/types/vine";

package/src/types/middleware.d.ts

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

package/src/types/router.d.ts

@@ -1,5 +0,0 @@
-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/src/types/validator.d.ts

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

package/src/types/vine.d.ts

@@ -1,13 +0,0 @@
-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/src/utils/vine.ts

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

package/src/utils/vines/exists.ts

@@ -1,41 +0,0 @@
-import {defineValue, isEmpty} from "@bejibun/utils";
-import vine, {VineNumber, VineString} from "@vinejs/vine";
-import {QueryBuilderType} from "objection";
-import BaseModel from "@/bases/BaseModel";
-
-type Options = {
-    table: typeof BaseModel;
-    column?: string;
-    withTrashed?: boolean;
-};
-
-const exists = async (value: unknown, options: Options, field: any): Promise<void> => {
-    if (!field.isValid) return;
-
-    const column = defineValue(options.column, field.name);
-
-    let query: any = options.table;
-    if (options.withTrashed) query = query.withTrashed();
-    else query = query.query();
-
-    const row = await (query as QueryBuilderType<any>).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: any): void => {
-    Type.macro("exists", function (this: typeof Type, tableOrOptions: typeof BaseModel | Options, column?: string, withTrashed?: boolean) {
-        const isModel = typeof tableOrOptions === "function" && Object.prototype.isPrototypeOf.call(BaseModel, tableOrOptions);
-
-        const options: Options = isModel
-            ? {table: tableOrOptions as typeof BaseModel, column, withTrashed}
-            : tableOrOptions as Options;
-
-        return this.use(existsRule(options));
-    });
-};
-
-registerExistsMacro(VineString);
-registerExistsMacro(VineNumber);

package/src/utils/vines/unique.ts

@@ -1,41 +0,0 @@
-import {defineValue, isNotEmpty} from "@bejibun/utils";
-import vine, {VineNumber, VineString} from "@vinejs/vine";
-import {QueryBuilderType} from "objection";
-import BaseModel from "@/bases/BaseModel";
-
-type Options = {
-    table: typeof BaseModel;
-    column?: string;
-    withTrashed?: boolean;
-};
-
-const unique = async (value: unknown, options: Options, field: any): Promise<void> => {
-    if (!field.isValid) return;
-
-    const column = defineValue(options.column, field.name);
-
-    let query: any = options.table;
-    if (options.withTrashed) query = query.withTrashed();
-    else query = query.query();
-
-    const row = await (query as QueryBuilderType<any>).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: any): void => {
-    Type.macro("unique", function (this: typeof Type, tableOrOptions: typeof BaseModel | Options, column?: string, withTrashed?: boolean) {
-        const isModel = typeof tableOrOptions === "function" && Object.prototype.isPrototypeOf.call(BaseModel, tableOrOptions);
-
-        const options: Options = isModel
-            ? {table: tableOrOptions as typeof BaseModel, column, withTrashed}
-            : tableOrOptions as Options;
-
-        return this.use(uniqueRule(options));
-    });
-};
-
-registerUniqueMacro(VineString);
-registerUniqueMacro(VineNumber);