@avleon/core 0.0.5 → 0.0.7

package/README.md

@@ -1,4 +1,4 @@
 # avleon-core
 
 
-# Api (V0.0.)
+# Api (V0.0.1)

package/dist/authentication.d.ts

@@ -1,9 +1,7 @@
 export type CurrentUser = {};
-export declare abstract class Authetication {
-    abstract login(): void;
-    abstract register(): void;
-    abstract verifyToken(): boolean;
-    abstract currentUser(): CurrentUser;
+export declare abstract class BaseAuthetication {
+    abstract authenticate(): Promise<Boolean>;
+    abstract authorize(): Promise<Boolean>;
 }
 export declare function Authorized(): void;
 export declare function CurrentUser(): void;

package/dist/authentication.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Authetication = void 0;
+exports.BaseAuthetication = void 0;
 exports.Authorized = Authorized;
 exports.CurrentUser = CurrentUser;
-class Authetication {
+class BaseAuthetication {
 }
-exports.Authetication = Authetication;
+exports.BaseAuthetication = BaseAuthetication;
 function Authorized() {
 }
 function CurrentUser() { }

package/dist/config.d.ts

@@ -18,13 +18,12 @@ export interface IAppConfig {
     apiKey: string;
     timezone: string;
 }
-interface ConfigClass {
-    invoke(env: Environment): object;
+export interface IConfig {
+    config(env: Environment): object;
 }
-export declare function Config(target: {
-    new (...args: any[]): ConfigClass;
+export declare function Config<T extends IConfig>(target: {
+    new (): T;
 }): void;
-export declare function GetConfig<T extends ConfigClass>(ConfigClass: {
-    new (...args: any[]): T;
-}): ReturnType<T["invoke"]>;
-export {};
+export declare function GetConfig<T extends IConfig>(ConfigClass: {
+    new (): T;
+}): ReturnType<T["config"]>;

package/dist/config.js

@@ -3,17 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Config = Config;
 exports.GetConfig = GetConfig;
 const CONFIG_METADATA_KEY = Symbol("config");
+const configInstances = new Map();
 function Config(target) {
-    if (typeof target.prototype.invoke !== "function") {
-        throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
+    if (typeof target.prototype.config !== "function") {
+        throw new Error(`Class "${target.name}" must implement a "config" method.`);
     }
     Reflect.defineMetadata(CONFIG_METADATA_KEY, target, target);
+    // Auto-instantiate and store the config instance
+    configInstances.set(target.name, new target());
 }
 function GetConfig(ConfigClass) {
-    const ConfigCtor = Reflect.getMetadata(CONFIG_METADATA_KEY, ConfigClass);
-    if (!ConfigCtor) {
-        throw new Error(`Class "${ConfigClass.name}" is not decorated with @Config.`);
+    const instance = configInstances.get(ConfigClass.name);
+    if (!instance) {
+        throw new Error(`Class "${ConfigClass.name}" is not registered as a config.`);
     }
-    const instance = new ConfigCtor();
-    return instance.invoke(process.env);
+    return instance.config(process.env);
 }

package/dist/container.d.ts

@@ -7,6 +7,7 @@ export declare const REQUEST_BODY_META_KEY: unique symbol;
 export declare const REQUEST_USER_META_KEY: unique symbol;
 export declare const REQUEST_HEADER_META_KEY: unique symbol;
 export declare const DATASOURCE_META_KEY: unique symbol;
+export declare const AUTHORIZATION_META_KEY: unique symbol;
 declare const Container: typeof TypediContainer;
 export declare function registerController(controller: Function): void;
 export declare function registerService(service: Function): void;

package/dist/container.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.API_CONTROLLER_METADATA_KEY = exports.DATASOURCE_META_KEY = exports.REQUEST_HEADER_META_KEY = exports.REQUEST_USER_META_KEY = exports.REQUEST_BODY_META_KEY = exports.QUERY_META_KEY = exports.PARAM_META_KEY = exports.CONTROLLER_META_KEY = exports.ROUTE_META_KEY = void 0;
+exports.API_CONTROLLER_METADATA_KEY = exports.AUTHORIZATION_META_KEY = exports.DATASOURCE_META_KEY = exports.REQUEST_HEADER_META_KEY = exports.REQUEST_USER_META_KEY = exports.REQUEST_BODY_META_KEY = exports.QUERY_META_KEY = exports.PARAM_META_KEY = exports.CONTROLLER_META_KEY = exports.ROUTE_META_KEY = void 0;
 exports.registerController = registerController;
 exports.registerService = registerService;
 exports.getRegisteredServices = getRegisteredServices;
@@ -19,6 +19,7 @@ exports.REQUEST_BODY_META_KEY = Symbol("iparam:options");
 exports.REQUEST_USER_META_KEY = Symbol("iparam:options");
 exports.REQUEST_HEADER_META_KEY = Symbol("iheader:options");
 exports.DATASOURCE_META_KEY = Symbol("idatasource:options");
+exports.AUTHORIZATION_META_KEY = Symbol("idatasource:authorization");
 const controllerRegistry = new Set();
 const serviceRegistry = new Set();
 const optionsRegistry = new Map();

package/dist/controller.d.ts

@@ -35,7 +35,8 @@ export declare function createControllerDecorator(type?: "api" | "web"): (pathOr
  * @param path {string} this will used as route prefix
  *
  **/
-export declare function ApiController(path?: string): ClassDecorator;
+export declare function ApiController(target: Function): void;
+export declare function ApiController(path: string): ClassDecorator;
 /**
  *@description Api controller's are used for rest . It will populate
  * json on return and all it http methods {get} {post} etc must return

package/dist/controller.js

@@ -31,8 +31,22 @@ function createControllerDecorator(type = "web") {
     };
 }
 function ApiController(pathOrOptions = "/", mayBeOptions) {
-    if (mayBeOptions) {
-        return createControllerDecorator("api")(pathOrOptions, mayBeOptions);
+    if (typeof pathOrOptions == 'function') {
+        Reflect.defineMetadata(container_1.API_CONTROLLER_METADATA_KEY, true, pathOrOptions);
+        // Ensure Service is applied as a ClassDecorator
+        if (typeof typedi_1.Service === "function") {
+            (0, container_1.registerController)(pathOrOptions); // Add to custom registry
+            (0, typedi_1.Service)()(pathOrOptions); // Apply DI decorator
+            Reflect.defineMetadata(container_1.CONTROLLER_META_KEY, { type: 'api', path: "/", options: {} }, pathOrOptions);
+        }
+        else {
+            throw new Error("Service decorator is not a function");
+        }
+    }
+    else {
+        if (mayBeOptions) {
+            return createControllerDecorator("api")(pathOrOptions, mayBeOptions);
+        }
+        return createControllerDecorator("api")(pathOrOptions);
     }
-    return createControllerDecorator("api")(pathOrOptions);
 }

package/dist/helpers.d.ts

@@ -1,6 +1,7 @@
 export declare const uuid: `${string}-${string}-${string}-${string}-${string}`;
 export declare function inject<T>(cls: new (...args: any[]) => T): T;
 export type Constructor<T = any> = new (...args: any[]) => T;
+export declare function isConstructor(func: any): boolean;
 export declare function formatUrl(path: string): string;
 export declare function parsedPath(ipath: string): string;
 export declare const isClassValidator: (target: Constructor) => boolean;

package/dist/helpers.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isClassValidatorClass = exports.getLineNumber = exports.isClassValidator = exports.uuid = void 0;
 exports.inject = inject;
+exports.isConstructor = isConstructor;
 exports.formatUrl = formatUrl;
 exports.parsedPath = parsedPath;
 exports.normalizePath = normalizePath;
@@ -34,6 +35,28 @@ function inject(cls) {
         throw new system_exception_1.SystemUseError(`Not  a project class. Maybe you  wanna register it first.`);
     }
 }
+function isConstructor(func) {
+    // Check if the func is a function
+    if (typeof func !== 'function') {
+        return false;
+    }
+    // Check if it's an arrow function or a built-in JavaScript function
+    if (func === Function.prototype.bind || func instanceof RegExp) {
+        return false;
+    }
+    // Check if it has a `prototype` property
+    if (func.prototype && typeof func.prototype === 'object') {
+        return true;
+    }
+    // If it's not a constructor, check if it can be called with the new keyword
+    try {
+        const instance = new func();
+        return typeof instance === 'object';
+    }
+    catch (e) {
+        return false;
+    }
+}
 function formatUrl(path) {
     if (typeof path !== "string") {
         throw new Error("The path must be a string");

package/dist/icore.d.ts

@@ -1,5 +1,6 @@
-import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
+import { FastifyInstance, FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
 import { Constructor } from "./helpers";
+import { PathLike } from "fs";
 import { DataSourceOptions } from "typeorm";
 import { AppMiddleware } from "./middleware";
 import { OpenApiOptions, OpenApiUiOptions } from "./openapi";
@@ -37,6 +38,10 @@ export interface MethodParamMeta {
     currentUser: ParamMetaOptions[];
     swagger?: OpenApiUiOptions;
 }
+type StaticFileOptions = {
+    path?: PathLike;
+    prefix?: string;
+};
 declare class AvleonApplication {
     private static instance;
     private static buildOptions;
@@ -49,6 +54,7 @@ declare class AvleonApplication {
     private hasSwagger;
     private globalSwaggerOptions;
     private controllers;
+    private authorizeMiddleware?;
     private constructor();
     static getInternalApp(buildOptions: any): AvleonApplication;
     isDevelopment(): boolean;
@@ -67,6 +73,7 @@ declare class AvleonApplication {
     handleRoute(args: any): Promise<void>;
     private mapFn;
     useMiddlewares<T extends AppMiddleware>(mclasses: Constructor<T>[]): void;
+    useAuthoriztion<T extends any>(middleware: Constructor<T>): void;
     private _handleError;
     mapRoute<T extends (...args: any[]) => any>(method: "get" | "post" | "put" | "delete", path: string | undefined, fn: T): Promise<void>;
     private _routeHandler;
@@ -86,7 +93,9 @@ declare class AvleonApplication {
         useMiddleware: <M extends AppMiddleware>(middlewares: Constructor<AppMiddleware>[]) => /*elided*/ any;
         useSwagger: (options: OpenApiOptions) => /*elided*/ any;
     };
+    useStaticFiles(options?: StaticFileOptions): void;
     run(port?: number): Promise<void>;
+    getTestApp(app: AvleonApplication): FastifyInstance<import("fastify").RawServerDefault, import("http").IncomingMessage, import("http").ServerResponse<import("http").IncomingMessage>, import("fastify").FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
 }
 export declare class Builder {
     private static instance;
@@ -95,6 +104,7 @@ export declare class Builder {
     private dataSource?;
     private constructor();
     static createAppBuilder(): Builder;
+    static creatTestAppBilder(): Builder;
     registerPlugin<T extends Function, S extends {}>(plugin: T, options: S): Promise<void>;
     addDataSource(config: DataSourceOptions): Promise<void>;
     build(): AvleonApplication;

package/dist/icore.js

@@ -57,7 +57,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Builder = void 0;
 const fastify_1 = __importDefault(require("fastify"));
 const typedi_1 = __importDefault(require("typedi"));
-const promises_1 = __importDefault(require("fs/promises")); // Use promises for asynchronous file operations
+const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const container_1 = __importStar(require("./container"));
 const helpers_1 = require("./helpers");
@@ -65,7 +65,6 @@ const system_exception_1 = require("./exceptions/system-exception");
 const fs_1 = require("fs");
 const exceptions_1 = require("./exceptions");
 const swagger_1 = __importDefault(require("@fastify/swagger"));
-const fastify_api_reference_1 = __importDefault(require("@scalar/fastify-api-reference"));
 const environment_variables_1 = require("./environment-variables");
 const isTsNode = process.env.TS_NODE_DEV ||
     process.env.TS_NODE_PROJECT ||
@@ -82,6 +81,7 @@ class AvleonApplication {
         this.hasSwagger = false;
         this.globalSwaggerOptions = {};
         this.controllers = [];
+        this.authorizeMiddleware = undefined;
         this.metaCache = new Map();
         this.app = (0, fastify_1.default)();
         // this.app.setValidatorCompiler(() => () => true);
@@ -96,25 +96,28 @@ class AvleonApplication {
         return AvleonApplication.instance;
     }
     isDevelopment() {
-        return environment_variables_1.env['NODE_ENV'] == "development";
+        return environment_variables_1.env["NODE_ENV"] == "development";
     }
     async initSwagger(options) {
-        const { routePrefix } = options, restOptions = __rest(options, ["routePrefix"]);
+        const { routePrefix, logo, theme } = options, restOptions = __rest(options, ["routePrefix", "logo", "theme"]);
         this.app.register(swagger_1.default, {
-            openapi: Object.assign({ openapi: '3.0.0' }, restOptions)
+            openapi: Object.assign({ openapi: "3.0.0" }, restOptions),
         });
         const rPrefix = routePrefix ? routePrefix : "/docs";
         //import fastifyApiReference from "@scalar/fastify-api-reference";
-        await this.app.register(fastify_api_reference_1.default, {
+        //const fastifyApiReference = await require("@scalar/fastify-api-reference");
+        await this.app.register(require("@fastify/swagger-ui"), {
+            logo: logo ? logo : null,
+            theme: theme ? theme : {},
             routePrefix: rPrefix,
             configuration: {
                 metaData: {
-                    title: 'Avleon Api',
-                    ogTitle: 'Avleon'
+                    title: "Avleon Api",
+                    ogTitle: "Avleon",
                 },
-                theme: 'kepler',
-                favicon: '/static/favicon.png'
-            }
+                theme: "kepler",
+                favicon: "/static/favicon.png",
+            },
         });
     }
     async useSwagger(options) {
@@ -146,6 +149,13 @@ class AvleonApplication {
         let classMiddlewares = [];
         const tag = ctrl.constructor.name.replace("Controller", "");
         const swaggerControllerMeta = Reflect.getMetadata("controller:openapi", ctrl.constructor) || {};
+        const authClsMeata = Reflect.getMetadata(container_1.AUTHORIZATION_META_KEY, ctrl.constructor) || { authorize: false, options: undefined };
+        if (authClsMeata.authorize && this.authorizeMiddleware) {
+            this.app.addHook("preHandler", (req, res) => {
+                return this.authorizeMiddleware.authorize(req);
+            });
+        }
+        console.log("ClassMiddlware:", tag + ":", authClsMeata);
         try {
             for (var _d = true, methods_1 = __asyncValues(methods), methods_1_1; methods_1_1 = await methods_1.next(), _a = methods_1_1.done, !_a; _d = true) {
                 _c = methods_1_1.value;
@@ -165,6 +175,7 @@ class AvleonApplication {
                 const classMiddlewares = this.executeMiddlewares(ctrl, method);
                 // handle openapi data
                 const swaggerMeta = Reflect.getMetadata("route:openapi", prototype, method) || {};
+                const authClsMethodMeata = Reflect.getMetadata(container_1.AUTHORIZATION_META_KEY, ctrl.constructor, method) || { authorize: false, options: undefined };
                 const allMeta = this._processMeta(prototype, method);
                 const routePath = methodmetaOptions.path == "" ? "/" : methodmetaOptions.path;
                 this.app.route({
@@ -173,10 +184,16 @@ class AvleonApplication {
                     schema: Object.assign(Object.assign(Object.assign({}, swaggerControllerMeta), swaggerMeta), { tags: [tag] }),
                     handler: async (req, res) => {
                         let reqClone = req;
+                        if (authClsMethodMeata.authorize && this.authorizeMiddleware) {
+                            const cls = container_1.default.get(this.authorizeMiddleware);
+                            await cls.authorize(reqClone, authClsMethodMeata.options);
+                            if (res.sent)
+                                return;
+                        }
                         if (classMiddlewares.length > 0) {
                             for (let m of classMiddlewares) {
                                 const cls = typedi_1.default.get(m.constructor);
-                                reqClone = await cls.invoke(reqClone, res);
+                                reqClone = (await cls.invoke(reqClone, res));
                                 if (res.sent)
                                     return;
                             }
@@ -297,11 +314,24 @@ class AvleonApplication {
             this.app.addHook("preHandler", cls.invoke);
         }
     }
+    useAuthoriztion(middleware) {
+        this.authorizeMiddleware = middleware;
+    }
     _handleError(error) {
         if (error instanceof exceptions_1.BaseHttpException) {
-            return { code: error.code, error: error.name, message: (0, helpers_1.isValidJsonString)(error.message) ? JSON.parse(error.message) : error.message };
+            return {
+                code: error.code,
+                error: error.name,
+                message: (0, helpers_1.isValidJsonString)(error.message)
+                    ? JSON.parse(error.message)
+                    : error.message,
+            };
         }
-        return { code: 500, error: 'INTERNALERROR', message: error.message ? error.message : "Something going wrong." };
+        return {
+            code: 500,
+            error: "INTERNALERROR",
+            message: error.message ? error.message : "Something going wrong.",
+        };
     }
     async mapRoute(method, path = "", fn) {
         await this.mapFn(fn); // Assuming mapFn is needed for all methods
@@ -328,7 +358,7 @@ class AvleonApplication {
         this.rMap.set(routeKey, {
             handler: fn,
             middlewares: [],
-            schema: {}
+            schema: {},
         });
         this.mapFn(fn);
         const route = {
@@ -367,16 +397,18 @@ class AvleonApplication {
     mapDelete(path = "", fn) {
         return this._routeHandler(path, "DELETE", fn);
     }
+    useStaticFiles(options = { path: undefined, prefix: undefined }) {
+        this.app.register(require("@fastify/static"), {
+            root: options.path ? options.path : path_1.default.join(process.cwd(), "public"),
+            prefix: options.prefix ? options.prefix : "/static/",
+        });
+    }
     async run(port = 4000) {
         if (this.alreadyRun)
             throw new system_exception_1.SystemUseError("App already running");
         this.alreadyRun = true;
         if (AvleonApplication.buildOptions.database) {
         }
-        this.app.register(require('@fastify/static'), {
-            root: path_1.default.join(process.cwd(), 'public'),
-            prefix: '/static/'
-        });
         //this.app.swagger();
         if (this.hasSwagger) {
             await this.initSwagger(this.globalSwaggerOptions);
@@ -401,7 +433,11 @@ class AvleonApplication {
         this.app.setErrorHandler(async (error, req, res) => {
             const handledErr = this._handleError(error);
             if (error instanceof exceptions_1.ValidationErrorException) {
-                return res.status(handledErr.code).send({ code: handledErr.code, error: handledErr.error, errors: handledErr.message });
+                return res.status(handledErr.code).send({
+                    code: handledErr.code,
+                    error: handledErr.error,
+                    errors: handledErr.message,
+                });
             }
             return res.status(handledErr.code).send(handledErr);
         });
@@ -409,6 +445,9 @@ class AvleonApplication {
         await this.app.listen({ port });
         console.log(`Application running on port: 0.0.0.0:${port}`);
     }
+    getTestApp(app) {
+        return this.app;
+    }
 }
 AvleonApplication.buildOptions = {};
 // Applciation Builder
@@ -423,6 +462,12 @@ class Builder {
         }
         return Builder.instance;
     }
+    static creatTestAppBilder() {
+        if (!Builder.instance) {
+            Builder.instance = new Builder();
+        }
+        return Builder.instance;
+    }
     async registerPlugin(plugin, options) {
         container_1.default.set(plugin, plugin.prototype);
     }

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from "./map-types";
 export * from "./response";
 export * from "./exceptions";
 export * from "./validator-extend";
+export * from "./validation";
 export * from "./environment-variables";
 export * from "./collection";
 export * from "./queue";

package/dist/index.js

@@ -31,6 +31,7 @@ __exportStar(require("./map-types"), exports);
 __exportStar(require("./response"), exports);
 __exportStar(require("./exceptions"), exports);
 __exportStar(require("./validator-extend"), exports);
+__exportStar(require("./validation"), exports);
 __exportStar(require("./environment-variables"), exports);
 __exportStar(require("./collection"), exports);
 __exportStar(require("./queue"), exports);

package/dist/middleware.d.ts

@@ -3,8 +3,22 @@ import { HttpException } from "./exceptions";
 export declare abstract class AppMiddleware {
     abstract invoke(req: IRequest, res?: IResponse): Promise<IRequest | HttpException>;
 }
+export type AuthHandler = (req: IRequest, roles?: string[]) => Promise<IRequest | HttpException>;
 export type Constructor<T> = {
     new (...args: any[]): T;
 };
+export declare abstract class AuthorizeMiddleware {
+    abstract authorize(roles: string[]): (req: IRequest, res?: IResponse) => IRequest | Promise<IRequest>;
+}
+export type AuthReturnTypes = IRequest | Promise<IRequest>;
+interface AuthorizeClass {
+    authorize(req: IRequest, options?: any): AuthReturnTypes;
+}
+export declare function Authorize(target: {
+    new (...args: any[]): AuthorizeClass;
+}): void;
+export declare function Authorized(): ClassDecorator & MethodDecorator;
+export declare function Authorized(options?: any): ClassDecorator & MethodDecorator;
 export declare function Middleware(target: Constructor<AppMiddleware>): void;
 export declare function UseMiddleware<T extends AppMiddleware | (new (...args: any[]) => AppMiddleware)>(options: T | T[]): MethodDecorator & ClassDecorator;
+export {};

package/dist/middleware.js

@@ -1,12 +1,40 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppMiddleware = void 0;
+exports.AuthorizeMiddleware = exports.AppMiddleware = void 0;
+exports.Authorize = Authorize;
+exports.Authorized = Authorized;
 exports.Middleware = Middleware;
 exports.UseMiddleware = UseMiddleware;
 const typedi_1 = require("typedi");
+const container_1 = require("./container");
 class AppMiddleware {
 }
 exports.AppMiddleware = AppMiddleware;
+class AuthorizeMiddleware {
+}
+exports.AuthorizeMiddleware = AuthorizeMiddleware;
+function Authorize(target) {
+    if (typeof target.prototype.authorize !== "function") {
+        throw new Error(`Class "${target.name}" must implement an "authorize" method.`);
+    }
+    (0, typedi_1.Service)()(target);
+}
+function Authorized(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        if (propertyKey && descriptor) {
+            Reflect.defineMetadata(container_1.AUTHORIZATION_META_KEY, { authorize: true, options }, target.constructor, propertyKey);
+        }
+        else {
+            Reflect.defineMetadata(container_1.AUTHORIZATION_META_KEY, { authorize: true, options }, target);
+        }
+    };
+}
+function Middleware(target) {
+    if (typeof target.prototype.invoke !== "function") {
+        throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
+    }
+    (0, typedi_1.Service)()(target);
+}
 // export function CurrentUser(): ParameterDecorator {
 //   return (target, propertyKey, parameterIndex) => {
 //     const existingMetadata =
@@ -15,12 +43,6 @@ exports.AppMiddleware = AppMiddleware;
 //     Reflect.defineMetadata("currentUser:params", existingMetadata, target, propertyKey!);
 //   };
 // }
-function Middleware(target) {
-    if (typeof target.prototype.invoke !== "function") {
-        throw new Error(`Class "${target.name}" must implement an "invoke" method.`);
-    }
-    (0, typedi_1.Service)()(target);
-}
 function UseMiddleware(options) {
     return function (target, propertyKey, descriptor) {
         const normalizeMiddleware = (middleware) => typeof middleware === "function" ? new middleware() : middleware;

package/dist/openapi.d.ts

@@ -28,6 +28,8 @@ interface ServerVariableObject {
     description?: string;
 }
 export type OpenApiUiOptions = {
+    logo?: any;
+    theme?: any;
     openapi?: string;
     routePrefix?: string;
     info?: InfoObject;

package/dist/swagger-schema.js

@@ -4,6 +4,7 @@ exports.generateSwaggerSchema = generateSwaggerSchema;
 function generateSwaggerSchema(classType) {
     const { getMetadataStorage } = require("class-validator");
     const { plainToInstance } = require("class-transformer");
+    //const { isArray } = require("lodash"); // Add lodash for array check
     const metadataStorage = getMetadataStorage();
     const validationMetadata = metadataStorage.getTargetValidationMetadatas(classType, "", true);
     const schema = {
@@ -12,18 +13,136 @@ function generateSwaggerSchema(classType) {
         required: [],
     };
     validationMetadata.forEach((meta) => {
+        var _a, _b;
         const propertyName = meta.propertyName;
         // Infer the type dynamically using Reflect metadata
         const propertyType = Reflect.getMetadata("design:type", classType.prototype, propertyName);
-        schema.properties[propertyName] = {
-            type: (propertyType === null || propertyType === void 0 ? void 0 : propertyType.name.toLowerCase()) || "string", // Default to string if type cannot be inferred
-        };
-        if (meta.name === "isNotEmpty") {
-            schema.required.push(propertyName);
-        }
-        if (meta.name === "minLength") {
-            schema.properties[propertyName].minLength = meta.constraints[0];
+        let swaggerProperty = {};
+        switch (propertyType) {
+            case String:
+                swaggerProperty.type = "string";
+                break;
+            case Number:
+                swaggerProperty.type = "number";
+                break;
+            case Boolean:
+                swaggerProperty.type = "boolean";
+                break;
+            case Date:
+                swaggerProperty.type = "string";
+                swaggerProperty.format = "date-time";
+                break;
+            case Array:
+                // Attempt to infer array item type
+                const arrayItemType = Reflect.getMetadata("design:type", classType.prototype, propertyName + "[0]" // Attempt to get array item type. Very fragile.
+                );
+                if (arrayItemType) {
+                    swaggerProperty.type = "array";
+                    swaggerProperty.items = {
+                        type: arrayItemType.name.toLowerCase(), // basic type inference
+                    };
+                    if (arrayItemType === Object) {
+                        //try to infer the Object type within array
+                        const nestedSchema = generateSwaggerSchema(Reflect.getMetadata("design:type", classType.prototype, propertyName + "[0]"));
+                        swaggerProperty.items = nestedSchema;
+                    }
+                }
+                else {
+                    swaggerProperty.type = "array";
+                    swaggerProperty.items = {}; // Array of unknown type
+                }
+                break;
+            case Object:
+                //Nested object
+                const nestedSchema = generateSwaggerSchema(Reflect.getMetadata("design:type", classType.prototype, propertyName));
+                swaggerProperty = nestedSchema;
+                break;
+            default:
+                swaggerProperty.type = ((_a = propertyType === null || propertyType === void 0 ? void 0 : propertyType.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "string"; // Default to string if type cannot be inferred
         }
+        schema.properties[propertyName] = swaggerProperty;
+        (_b = meta.constraints) === null || _b === void 0 ? void 0 : _b.forEach((constraint) => {
+            switch (constraint.name) {
+                case "isNotEmpty":
+                    if (!schema.required.includes(propertyName)) {
+                        schema.required.push(propertyName);
+                    }
+                    break;
+                case "minLength":
+                    schema.properties[propertyName].minLength = constraint.constraints[0];
+                    break;
+                case "maxLength":
+                    schema.properties[propertyName].maxLength = constraint.constraints[0];
+                    break;
+                case "min":
+                    schema.properties[propertyName].minimum = constraint.constraints[0];
+                    break;
+                case "max":
+                    schema.properties[propertyName].maximum = constraint.constraints[0];
+                    break;
+                case "isEmail":
+                    schema.properties[propertyName].format = "email";
+                    break;
+                case "isDate":
+                    schema.properties[propertyName].format = "date-time";
+                    break;
+                case "isIn":
+                    schema.properties[propertyName].enum = constraint.constraints[0];
+                    break;
+                case "isNumber":
+                    schema.properties[propertyName].type = "number";
+                    break;
+                case "isInt":
+                    schema.properties[propertyName].type = "integer";
+                    break;
+                case "isBoolean":
+                    schema.properties[propertyName].type = "boolean";
+                    break;
+                case "isString":
+                    schema.properties[propertyName].type = "string";
+                    break;
+                case "isOptional":
+                    if (schema.required.includes(propertyName)) {
+                        schema.required = schema.required.filter((item) => item !== propertyName);
+                    }
+                    break;
+                // Add more cases for other validators as needed
+            }
+        });
     });
     return schema;
 }
+// export function generateSwaggerSchema(classType: any) {
+//   const { getMetadataStorage } = require("class-validator");
+//   const { plainToInstance } = require("class-transformer");
+//   const metadataStorage = getMetadataStorage();
+//   const validationMetadata = metadataStorage.getTargetValidationMetadatas(
+//     classType,
+//     "",
+//     true,
+//   );
+//   const schema: any = {
+//     type: "object",
+//     properties: {},
+//     required: [],
+//   };
+//   validationMetadata.forEach((meta: any) => {
+//     const propertyName = meta.propertyName;
+//     // Infer the type dynamically using Reflect metadata
+//     const propertyType = Reflect.getMetadata(
+//       "design:type",
+//       classType.prototype,
+//       propertyName,
+//     );
+//     schema.properties[propertyName] = {
+//       type: propertyType?.name.toLowerCase() || "string", // Default to string if type cannot be inferred
+//     };
+//     if (meta.name === "isNotEmpty") {
+//       schema.required.push(propertyName);
+//     }
+//     if (meta.name === "minLength") {
+//       schema.properties[propertyName].minLength = meta.constraints[0];
+//     }
+//   });
+//   return schema;
+// }

package/dist/validation.d.ts

@@ -0,0 +1,23 @@
+type BaseRule = {
+    required?: boolean;
+    optional?: boolean;
+    message?: string;
+};
+type StringRule = BaseRule & {
+    type: "string";
+};
+type NumberRule = BaseRule & {
+    type: "number";
+    min?: number;
+    max?: number;
+    exact?: number;
+};
+type BooleanRule = BaseRule & {
+    type: "boolean";
+};
+export type ValidationRule = StringRule | NumberRule | BooleanRule;
+export type ValidationProps = {
+    [key: string]: ValidationRule;
+};
+export declare function validateOrThrow<T extends {}>(obj: T, rules: ValidationProps): any;
+export {};

package/dist/validation.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOrThrow = validateOrThrow;
+const exceptions_1 = require("./exceptions");
+class PValidationRule {
+    constructor(name, type, message) {
+        this.name = name;
+        this.type = type;
+        this.message = message;
+    }
+}
+class Validator {
+    constructor(obj) {
+        this.rules = [];
+        this.init(obj);
+    }
+    init(obj) {
+        Object.keys(obj).forEach((key) => {
+            const rule = obj[key];
+            this.rules.push(new PValidationRule(key, rule.type, rule.message));
+        });
+    }
+    validate(obj) {
+        const erors = [];
+        this.rules.forEach((k) => {
+            const r = Object.keys(obj).find((key) => key == k.name);
+            let messages = [];
+            if (!r || obj[r] == undefined || obj[r] == "") {
+                messages.push({
+                    constraint: "required",
+                    message: k.name + " is required",
+                });
+            }
+            if (k.type == "string" && typeof obj[k.name] != "string") {
+                messages.push({
+                    constraint: "type",
+                    message: `${k.name} must be type ${k.type}`,
+                });
+            }
+            if (k.type == "number" && !parseInt(obj[k.name])) {
+                messages.push({
+                    constraint: "type",
+                    message: `${k.name} must be type ${k.type}`,
+                });
+            }
+            if (k.type == "number") {
+                obj[k.name] = parseInt(obj[k.name]);
+            }
+            if (k.type == "boolean" && !isBool(obj[k.name])) {
+                messages.push({
+                    constraint: "type",
+                    message: `${k.name} must be type ${k.type}`,
+                });
+            }
+            if (k.type == "boolean") {
+                obj[k.name] = parseBoolean(obj[k.name]);
+            }
+            if (messages.length > 0) {
+                erors.push({
+                    path: k.name,
+                    messages: messages,
+                });
+            }
+        });
+        return [erors, obj];
+    }
+}
+const isBool = (val) => {
+    if (typeof val == "boolean")
+        return true;
+    if (parseInt(val) == 0 || parseInt(val) == 1)
+        return true;
+    if (val == "true" || val == "false")
+        return true;
+    return false;
+};
+const parseBoolean = (val) => {
+    if (typeof val === "boolean")
+        return val;
+    // if (typeof val === "number") {
+    //   return val !== 0; // Common convention: 0 → false, any other number → true
+    // }
+    if (parseInt(val) == 1)
+        return true;
+    if (typeof val === "string") {
+        const normalized = val.trim().toLowerCase();
+        return normalized === "true";
+    }
+    return false; // Default for unsupported types (null, undefined, objects, etc.)
+};
+function validateOrThrow(obj, rules) {
+    const valid = new Validator(rules);
+    const errors = valid.validate(obj);
+    if (errors[0].length > 0) {
+        throw new exceptions_1.BadRequestException(errors[0]);
+    }
+    return errors[1];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
@@ -25,7 +25,6 @@
     "@fastify/static": "^8.1.1",
     "@fastify/swagger": "^9.4.0",
     "@fastify/swagger-ui": "^5.1.0",
-    "@scalar/fastify-api-reference": "^1.25.122",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "dotenv": "^16.4.7",
@@ -34,12 +33,15 @@
     "typedi": "^0.10.0",
     "typeorm": "^0.3.20"
   },
+  "peerDependencies": {
+    "@scalar/fastify-api-reference":"^1.25.130"
+  },
   "directories": {
     "test": "tests"
   },
   "description": "avleon core",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/xtareq/avleon-core"
+    "url": "git+https://github.com/avleonjs/avleon-core"
   }
 }