@bool-ts/core 1.3.1 → 1.4.0

package/.prettierrc

@@ -0,0 +1,11 @@
+{
+    "semi": true,
+    "tabWidth": 4,
+    "printWidth": 128,
+    "singleQuote": false,
+    "singleAttributePerLine": false,
+    "trailingComma": "none",
+    "bracketSameLine": true,
+    "bracketSpacing": true,
+    "htmlWhitespaceSensitivity": "ignore"
+}

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 BoolTS
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 BoolTS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__test/controller.ts

@@ -1,79 +1,66 @@
-import type { IService } from "./interfaces";
-
-import * as Zod from "zod";
-
-import { Controller, Delete, Get, Inject, Options, Patch, Post, Put, ZodSchema } from "../src";
-import { TestService } from "./service";
-import { Request, Response } from "express";
-
-
-const getAbcSchema = Zod.object({
-    headers: Zod.object({
-        authorization: Zod.string().min(10)
-    })
-});
-
-const stringSchema = Zod.object({}).refine(async (val) => {
-    const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
-    await delay(10000);
-
-    return val;
-});
-
-@Controller("test")
-export class TestController {
-    constructor(
-        @Inject(TestService) private readonly testService: IService
-    ) { }
-
-    @Get("abc")
-    private _get(
-        @ZodSchema(getAbcSchema) req: Request,
-        res: Response
-    ) {
-        console.log("this.testService", this.testService.exec())
-        res.json({ test: "success" }).send();
-    }
-
-    @Post("abc")
-    private _post(
-        @ZodSchema(getAbcSchema) req: Request,
-        res: Response
-    ) {
-        console.log("req.body", req.body);
-        res.json({ test: "success" }).send();
-    }
-
-    @Put()
-    private _put(
-        @ZodSchema(getAbcSchema) req: Request,
-        res: Response
-    ) {
-        res.json({ test: "success" }).send();
-    }
-
-    @Patch("abc/:id")
-    private _patch(
-        @ZodSchema(getAbcSchema) req: Request,
-        res: Response
-    ) {
-        console.log(req.params)
-        res.json({ test: "success" }).send();
-    }
-
-    @Delete()
-    private _delete(
-        req: Request,
-        @ZodSchema(stringSchema) res: Response
-    ) {
-        res.json({ test: "success" }).send();
-    }
-
-    @Options()
-    private _options(
-        @ZodSchema(getAbcSchema) req: Request,
-        res: Response
-    ) {
-        res.json({ test: "success" }).send();
-    }
-}
+import type { IService } from "./interfaces";
+
+import * as Zod from "zod";
+
+import { Body, Controller, Delete, Get, Inject, Options, Params, Patch, Post, Put, ZodSchema } from "../src";
+import { TestService } from "./service";
+
+const postParamsSchema = Zod.object({
+    id: Zod.string(),
+    providerId: Zod.string().uuid()
+});
+
+const bodySchema = Zod.object({
+    data: Zod.object({
+        name: Zod.string(),
+        age: Zod.number()
+    })
+});
+
+const requestSchema = Zod.object({
+    headers: Zod.object({
+        authorization: Zod.string().min(10)
+    }),
+    body: bodySchema
+});
+
+const stringSchema = Zod.object({}).refine(async (val) => {
+    const delay = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+    await delay(10000);
+
+    return val;
+});
+
+@Controller("test")
+export class TestController {
+    constructor(@Inject(TestService) private readonly testService: IService) {}
+
+    @Get("abc")
+    public get(req: Request) {
+        console.log("HEHE");
+        console.log("this.testService", this.testService.exec());
+    }
+
+    @Post("abc/:id/provider/:providerId")
+    public async post(
+        @Params(undefined, postParamsSchema)
+        params: any,
+        @Body(bodySchema)
+        req: Zod.infer<typeof bodySchema>
+    ) {
+        console.log("req.headers", req);
+        console.log("===========================");
+    }
+
+    @Put()
+    public put(req: any) {}
+
+    @Patch("abc/:testId")
+    public patch(req: Request) {}
+
+    @Delete()
+    public delete(req: Request) {}
+
+    @Options()
+    public options(req: Request) {}
+}

package/__test/index.ts

@@ -1,11 +1,8 @@
-import "reflect-metadata";
-
-import { BoolFactory } from "../src";
-import { TestModule } from "./module";
-
-
-const app = BoolFactory(TestModule);
-
-app.listen(3000, () => {
-    console.log(`Listening on port ${3000}...`);
-});
+import "reflect-metadata";
+
+import { BoolFactory } from "../src";
+import { TestModule } from "./module";
+
+BoolFactory(TestModule, {
+    port: 3000
+});

package/__test/interfaces.ts

@@ -1,7 +1,7 @@
-export interface IRepository {
-    exec(): void;
-}
-
-export interface IService {
-    exec(): void;
-}
+export interface IRepository {
+    exec(): void;
+}
+
+export interface IService {
+    exec(): void;
+}

package/__test/module.ts

@@ -1,17 +1,16 @@
-import { Module } from "../src";
-import { TestController } from "./controller";
-// import { TestRepository } from "./repository";
-import { TestService } from "./service";
-
-@Module({
-    controllers: [
-        TestController
-    ],
-    dependencies: [
-        // TestService,
-        // TestRepository
-    ]
-})
-export class TestModule { }
-
-export default TestModule;
+import { Module } from "../src";
+import { TestController } from "./controller";
+// import { TestRepository } from "./repository";
+import { TestService } from "./service";
+
+@Module({
+    allowOrigins: ["http://localhost:7000"],
+    controllers: [TestController],
+    dependencies: [
+        // TestService,
+        // TestRepository
+    ]
+})
+export class TestModule {}
+
+export default TestModule;

package/__test/repository.ts

@@ -1,16 +1,16 @@
-import type { IRepository } from "./interfaces";
-
-import { Injectable } from "../src";
-
-
-@Injectable()
-export class TestRepository implements IRepository {
-    /**
-     * 
-     */
-    exec() {
-        console.log("This is test repository.");
-    }
-}
-
-export default TestRepository;
+import type { IRepository } from "./interfaces";
+
+import { Injectable } from "../src";
+
+
+@Injectable()
+export class TestRepository implements IRepository {
+    /**
+     * 
+     */
+    exec() {
+        console.log("This is test repository.");
+    }
+}
+
+export default TestRepository;

package/__test/service.ts

@@ -1,20 +1,20 @@
-import type { IService, IRepository } from "./interfaces";
-
-import { Inject, Injectable } from "../src";
-import { TestRepository } from "./repository";
-
-
-@Injectable()
-export class TestService implements IService {
-    constructor(
-        @Inject(TestRepository) private readonly testRepository: IRepository
-    ) { }
-
-    /**
-     * 
-     */
-    exec() {
-        console.log("This is test service.", this.testRepository);
-        this.testRepository.exec();
-    }
-}
+import type { IService, IRepository } from "./interfaces";
+
+import { Inject, Injectable } from "../src";
+import { TestRepository } from "./repository";
+
+
+@Injectable()
+export class TestService implements IService {
+    constructor(
+        @Inject(TestRepository) private readonly testRepository: IRepository
+    ) { }
+
+    /**
+     * 
+     */
+    exec() {
+        console.log("This is test service.", this.testRepository);
+        this.testRepository.exec();
+    }
+}

package/dist/decorators/arguments.d.ts

@@ -0,0 +1,31 @@
+import * as Zod from "zod";
+export declare enum EArgumentTypes {
+    headers = "HEADERS",
+    body = "BODY",
+    params = "PARAMS",
+    query = "QUERY"
+}
+export type TMetadata = {
+    index: number;
+    type: EArgumentTypes.headers;
+    zodSchema?: Zod.Schema;
+} | {
+    index: number;
+    type: EArgumentTypes.body;
+    zodSchema?: Zod.Schema;
+    parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text";
+} | {
+    index: number;
+    type: EArgumentTypes.params;
+    key?: string;
+    zodSchema?: Zod.Schema;
+} | {
+    index: number;
+    type: EArgumentTypes.query;
+    zodSchema?: Zod.Schema;
+};
+export declare const controllerActionArgumentsKey: unique symbol;
+export declare const Headers: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Body: (zodSchema?: Zod.Schema, parser?: "arrayBuffer" | "blob" | "formData" | "json" | "text") => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Params: (key?: string, zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;
+export declare const Query: (zodSchema?: Zod.Schema) => (target: Object, methodName: string | symbol | undefined, parameterIndex: number) => void;

package/dist/decorators/arguments.js

@@ -0,0 +1,67 @@
+import * as Zod from "zod";
+export var EArgumentTypes;
+(function (EArgumentTypes) {
+    EArgumentTypes["headers"] = "HEADERS";
+    EArgumentTypes["body"] = "BODY";
+    EArgumentTypes["params"] = "PARAMS";
+    EArgumentTypes["query"] = "QUERY";
+})(EArgumentTypes || (EArgumentTypes = {}));
+export const controllerActionArgumentsKey = Symbol.for("__bool:controller.action::arguments__");
+export const Headers = (zodSchema) => {
+    return (target, methodName, parameterIndex) => {
+        if (!methodName) {
+            return;
+        }
+        const headersMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        headersMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.headers,
+            zodSchema: zodSchema
+        };
+        Reflect.defineMetadata(controllerActionArgumentsKey, headersMetadata, target.constructor, methodName);
+    };
+};
+export const Body = (zodSchema, parser) => {
+    return (target, methodName, parameterIndex) => {
+        if (!methodName) {
+            return;
+        }
+        const bodyMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        bodyMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.body,
+            zodSchema: zodSchema,
+            parser: parser
+        };
+        Reflect.defineMetadata(controllerActionArgumentsKey, bodyMetadata, target.constructor, methodName);
+    };
+};
+export const Params = (key, zodSchema) => {
+    return (target, methodName, parameterIndex) => {
+        if (!methodName) {
+            return;
+        }
+        const paramsMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        paramsMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.params,
+            key: key,
+            zodSchema: zodSchema
+        };
+        Reflect.defineMetadata(controllerActionArgumentsKey, paramsMetadata, target.constructor, methodName);
+    };
+};
+export const Query = (zodSchema) => {
+    return (target, methodName, parameterIndex) => {
+        if (!methodName) {
+            return;
+        }
+        const queryMetadata = Reflect.getOwnMetadata(controllerActionArgumentsKey, target.constructor, methodName) || {};
+        queryMetadata[`argumentIndexes.${parameterIndex}`] = {
+            index: parameterIndex,
+            type: EArgumentTypes.params,
+            zodSchema: zodSchema
+        };
+        Reflect.defineMetadata(controllerActionArgumentsKey, queryMetadata, target.constructor, methodName);
+    };
+};

package/dist/decorators/controller.d.ts

@@ -1,3 +1,3 @@
-export declare const controllerKey = "__bool:controller__";
-export declare const Controller: (prefix: string) => <T extends Object>(target: T, context?: ClassDecoratorContext) => T;
+export declare const controllerKey: unique symbol;
+export declare const Controller: (prefix: string) => <T extends Object>(target: T) => T;
 export default Controller;

package/dist/decorators/controller.js

@@ -1,12 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controller = exports.controllerKey = void 0;
-const injectable_1 = require("./injectable");
-exports.controllerKey = "__bool:controller__";
-const Controller = (prefix) => (target, context) => {
-    Reflect.defineMetadata(exports.controllerKey, !prefix.startsWith("/") ? `/${prefix}` : prefix, target);
-    Reflect.defineMetadata(injectable_1.injectableKey, undefined, target);
+import { injectableKey } from "./injectable";
+export const controllerKey = Symbol.for("__bool:controller__");
+export const Controller = (prefix) => (target) => {
+    Reflect.defineMetadata(controllerKey, !prefix.startsWith("/") ? `/${prefix}` : prefix, target);
+    Reflect.defineMetadata(injectableKey, undefined, target);
     return target;
 };
-exports.Controller = Controller;
-exports.default = exports.Controller;
+export default Controller;

package/dist/decorators/http.d.ts

@@ -4,7 +4,7 @@ export interface IControllerRoute {
     methodName: string;
     descriptor: PropertyDescriptor;
 }
-export declare const controllerRoutesKey = "__bool:controller.routes__";
+export declare const controllerRoutesKey: unique symbol;
 /**
  *
  * @param path

package/dist/decorators/http.js

@@ -1,17 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.controllerRoutesKey = void 0;
-const http_1 = require("../http");
-const ultils_1 = require("../ultils");
-const zodSchema_1 = require("./zodSchema");
-exports.controllerRoutesKey = "__bool:controller.routes__";
+export const controllerRoutesKey = Symbol.for("__bool:controller.routes__");
 const defaultDecorator = (path, method) => (target, methodName, descriptor) => {
     if (!(descriptor.value instanceof Function)) {
-        throw Error(`${method} decorator only use for method.`);
+        throw Error(`${method} decorator only use for class method.`);
     }
     // Define controller metadata
-    Reflect.defineMetadata(exports.controllerRoutesKey, [
-        ...Reflect.getOwnMetadata(exports.controllerRoutesKey, target.constructor) || [],
+    Reflect.defineMetadata(controllerRoutesKey, [
+        ...(Reflect.getOwnMetadata(controllerRoutesKey, target.constructor) || []),
         {
             path: !path.startsWith("/") ? `/${path}` : path,
             httpMethod: method.toUpperCase(),
@@ -19,126 +13,47 @@ const defaultDecorator = (path, method) => (target, methodName, descriptor) => {
             descriptor: descriptor
         }
     ], target.constructor);
-    // Define route parameters zod validation
-    const currentMethod = descriptor.value;
-    const isAsync = descriptor.value instanceof ultils_1.AsyncFunction;
-    if (!isAsync) {
-        descriptor.value = function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                    try {
-                        const validation = tmpZodMetadata.schema.safeParse(arguments[tmpZodMetadata.index]);
-                        if (!validation.success) {
-                            throw new http_1.HttpClientError({
-                                httpCode: 400,
-                                message: `Validation at the [${methodName}] method fails at positional argument [${tmpZodMetadata.index}].`,
-                                data: validation.error.issues
-                            });
-                        }
-                    }
-                    catch (error) {
-                        if (error instanceof http_1.HttpClientError) {
-                            throw error;
-                        }
-                        throw new http_1.HttpServerError({
-                            httpCode: 500,
-                            message: `Validation at the [${methodName}] method error at positional argument [${tmpZodMetadata.index}].`,
-                            data: !(error instanceof Error) ? error : [{
-                                    message: error.message,
-                                    code: error.name,
-                                    cause: error.cause
-                                }]
-                        });
-                    }
-                }
-            }
-            return currentMethod.apply(this, arguments);
-        };
-    }
-    else {
-        descriptor.value = async function () {
-            const zodSchemaMetadata = Reflect.getOwnMetadata(zodSchema_1.controllerRouteZodSchemaKey, target.constructor, methodName);
-            if (zodSchemaMetadata) {
-                for (const zodSchemaProp in zodSchemaMetadata) {
-                    const tmpZodMetadata = zodSchemaMetadata[zodSchemaProp];
-                    try {
-                        const validation = await tmpZodMetadata.schema.safeParseAsync(arguments[tmpZodMetadata.index]);
-                        if (!validation.success) {
-                            throw new http_1.HttpClientError({
-                                httpCode: 400,
-                                message: `Validation at the [${methodName}] method fails at positional argument [${tmpZodMetadata.index}].`,
-                                data: validation.error.issues
-                            });
-                        }
-                    }
-                    catch (error) {
-                        if (error instanceof http_1.HttpClientError) {
-                            throw error;
-                        }
-                        throw new http_1.HttpServerError({
-                            httpCode: 500,
-                            message: `Validation at the [${methodName}] method error at positional argument [${tmpZodMetadata.index}].`,
-                            data: !(error instanceof Error) ? error : [{
-                                    message: error.message,
-                                    code: error.name,
-                                    cause: error.cause
-                                }]
-                        });
-                    }
-                }
-            }
-            return currentMethod.apply(this, arguments);
-        };
-    }
 };
 /**
  *
  * @param path
  * @returns
  */
-const Get = (path = "/") => defaultDecorator(path, "Get");
-exports.Get = Get;
+export const Get = (path = "/") => defaultDecorator(path, "Get");
 /**
  *
  * @param path
  * @returns
  */
-const Post = (path = "/") => defaultDecorator(path, "Post");
-exports.Post = Post;
+export const Post = (path = "/") => defaultDecorator(path, "Post");
 /**
  *
  * @param path
  * @returns
  */
-const Put = (path = "/") => defaultDecorator(path, "Put");
-exports.Put = Put;
+export const Put = (path = "/") => defaultDecorator(path, "Put");
 /**
  *
  * @param path
  * @returns
  */
-const Patch = (path = "/") => defaultDecorator(path, "Patch");
-exports.Patch = Patch;
+export const Patch = (path = "/") => defaultDecorator(path, "Patch");
 /**
  *
  * @param path
  * @returns
  */
-const Delete = (path = "/") => defaultDecorator(path, "Delete");
-exports.Delete = Delete;
+export const Delete = (path = "/") => defaultDecorator(path, "Delete");
 /**
  *
  * @param path
  * @returns
  */
-const Options = (path = "/") => defaultDecorator(path, "Options");
-exports.Options = Options;
-exports.default = {
-    Get: exports.Get,
-    Post: exports.Post,
-    Put: exports.Put,
-    Patch: exports.Patch,
-    Delete: exports.Delete
+export const Options = (path = "/") => defaultDecorator(path, "Options");
+export default {
+    Get,
+    Post,
+    Put,
+    Patch,
+    Delete
 };

package/dist/decorators/index.d.ts

@@ -1,3 +1,4 @@
+export { Headers, Body, Params, Query, EArgumentTypes } from "./arguments";
 export { Controller, controllerKey } from "./controller";
 export { Inject, injectKey } from "./inject";
 export { Injectable, injectableKey } from "./injectable";