@bejibun/core 0.1.29 → 0.1.30

package/src/utils/utils.ts

@@ -0,0 +1,72 @@
+import type {EnumItem} from "@/facades/Enum";
+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: any): boolean => {
+    return (
+        value === undefined ||
+        value === null ||
+        value === false ||
+        value === 0 ||
+        value === 0n ||
+        (typeof value === "string" && value.trim() === "") ||
+        (Array.isArray(value) && value.length === 0) ||
+        (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0)
+    );
+};
+
+export const isNotEmpty = (value: any): boolean => {
+    return !isEmpty(value);
+};
+
+export const defineValue = (value: any, defaultValue: any = null): any => {
+    if (isNotEmpty(value)) return value;
+
+    return defaultValue;
+};
+
+export const ask = (question: string): Promise<string> => {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    return new Promise(resolve => {
+        return rl.question(question, (answer: string) => {
+            rl.close();
+
+            resolve(answer.trim());
+        });
+    });
+};
+
+export const cors = (): Record<string, string> => {
+    const configPath = path.resolve(process.cwd(), "config/cors.ts");
+
+    let corsConfig: any;
+
+    if (fs.existsSync(configPath)) corsConfig = require(configPath).default;
+    else corsConfig = require("@/config/cors").default;
+
+    const headers: Record<string, string> = {
+        "Access-Control-Allow-Origin": corsConfig.origin,
+        "Access-Control-Allow-Headers": Array.isArray(corsConfig.allowedHeaders)
+            ? corsConfig.allowedHeaders.join(", ")
+            : Enum.setEnums(CorsHeaderEnum).toArray().map((value: EnumItem) => value.value).join(", "),
+        "Access-Control-Allow-Methods": Array.isArray(corsConfig.methods)
+            ? corsConfig.methods.join(", ")
+            : Enum.setEnums(HttpMethodEnum).toArray().map((value: EnumItem) => 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/src/utils/vine.ts

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

package/src/utils/vines/exists.ts

@@ -0,0 +1,41 @@
+import vine, {VineNumber, VineString} from "@vinejs/vine";
+import {QueryBuilderType} from "objection";
+import BaseModel from "@/bases/BaseModel";
+import {defineValue, isEmpty} from "@/utils/utils";
+
+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

@@ -0,0 +1,41 @@
+import vine, {VineNumber, VineString} from "@vinejs/vine";
+import {QueryBuilderType} from "objection";
+import BaseModel from "@/bases/BaseModel";
+import {defineValue, isNotEmpty} from "@/utils/utils";
+
+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);

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "declaration": true,
+        "outDir": ".",
+        "esModuleInterop": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "baseUrl": ".",
+        "paths": {
+            "@/*": ["src/*"]
+        }
+    },
+    "exclude": ["node_modules"]
+}

package/dist/types/index.d.ts

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