@avleon/core 0.0.4 → 0.0.5

package/dist/helpers.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.isClassValidatorClass = exports.getLineNumber = exports.isClassValidator = void 0;
+exports.isClassValidatorClass = exports.getLineNumber = exports.isClassValidator = exports.uuid = void 0;
 exports.inject = inject;
 exports.formatUrl = formatUrl;
 exports.parsedPath = parsedPath;
@@ -17,34 +17,45 @@ exports.jsonToJs = jsonToJs;
 exports.jsonToInstance = jsonToInstance;
 exports.transformObjectByInstanceToObject = transformObjectByInstanceToObject;
 exports.validateObjectByInstance = validateObjectByInstance;
+exports.validateRequestBody = validateRequestBody;
 const class_transformer_1 = require("class-transformer");
 const exceptions_1 = require("./exceptions");
 const fs_1 = __importDefault(require("fs"));
 const container_1 = __importDefault(require("./container"));
+const system_exception_1 = require("./exceptions/system-exception");
+const crypto_1 = __importDefault(require("crypto"));
+const class_validator_1 = require("class-validator");
+exports.uuid = crypto_1.default.randomUUID();
 function inject(cls) {
-    return container_1.default.get(cls);
+    try {
+        return container_1.default.get(cls);
+    }
+    catch (error) {
+        throw new system_exception_1.SystemUseError(`Not  a project class. Maybe you  wanna register it first.`);
+    }
 }
 function formatUrl(path) {
-    if (typeof path !== 'string') {
-        throw new Error('The path must be a string');
+    if (typeof path !== "string") {
+        throw new Error("The path must be a string");
     }
     path = path.trim();
-    if (!path.startsWith('/')) {
-        path = '/' + path;
+    if (!path.startsWith("/")) {
+        path = "/" + path;
     }
-    path = path.replace(/\/\/+/g, '/');
-    if (path.endsWith('/')) {
+    path = path.replace(/\/\/+/g, "/");
+    if (path.endsWith("/")) {
         path = path.slice(0, -1);
     }
     return path;
 }
 function parsedPath(ipath) {
-    return !ipath.startsWith('/') ? '/' + ipath : ipath;
+    return !ipath.startsWith("/") ? "/" + ipath : ipath;
 }
 const isClassValidator = (target) => {
     try {
         const clsval = require("class-validator");
-        const result = clsval.getMetadataStorage().getTargetValidationMetadatas(target, undefined, false, false);
+        const result = (0, class_validator_1.getMetadataStorage)()
+            .getTargetValidationMetadatas(target, '', false, false);
         return result.length > 0;
     }
     catch (err) {
@@ -57,22 +68,21 @@ const getLineNumber = (filePath, rpath) => {
     var _a;
     let numbers = [];
     try {
-        const fileContent = fs_1.default.readFileSync(filePath, 'utf8'); // Read file content
-        const lines = fileContent.split('\n'); // Split content into line
+        const fileContent = fs_1.default.readFileSync(filePath, "utf8");
+        const lines = fileContent.split("\n");
         for (let i = 0; i < lines.length; i++) {
             const match = lines[i].match(rpath);
             if (match) {
                 console.log(match);
                 numbers.push({
-                    line: i + 1, // 1-based line number
-                    column: (_a = match.index) !== null && _a !== void 0 ? _a : 0 // 0-based column index
+                    line: i + 1,
+                    column: (_a = match.index) !== null && _a !== void 0 ? _a : 0,
                 });
             }
         }
-        return numbers; // Class not found
+        return numbers;
     }
     catch (error) {
-        //console.error(`Error reading file: ${error.message}`);
         return numbers;
     }
 };
@@ -81,10 +91,12 @@ function normalizePath(base = "/", subPath = "/") {
     return `/${base}/${subPath}`.replace(/\/+/g, "/").replace(/\/$/, "");
 }
 function extrctParamFromUrl(url) {
-    const splitPart = url.split("/").filter(x => x.startsWith(':') || x.startsWith("?:"));
-    return splitPart.map(f => ({
+    const splitPart = url
+        .split("/")
+        .filter((x) => x.startsWith(":") || x.startsWith("?:"));
+    return splitPart.map((f) => ({
         key: f.replace(/(\?|:)/g, ""),
-        required: !f.startsWith("?:")
+        required: !f.startsWith("?:"),
     }));
 }
 function findDuplicates(arr) {
@@ -98,13 +110,13 @@ function findDuplicates(arr) {
             seen.add(str);
         }
     }
-    return Array.from(duplicates); // Convert duplicates to an array if needed
+    return Array.from(duplicates);
 }
 function getDataType(expectedType) {
     switch (expectedType.name) {
         case "Object":
             if (Array.isArray(expectedType)) {
-                return 'array';
+                return "array";
             }
             return "object";
         case "String":
@@ -157,12 +169,17 @@ function jsonToInstance(value, instance) {
     }
 }
 function transformObjectByInstanceToObject(instance, value) {
-    return (0, class_transformer_1.instanceToPlain)((0, class_transformer_1.plainToInstance)(instance, value), { excludeExtraneousValues: true, exposeUnsetFields: true });
+    return (0, class_transformer_1.instanceToPlain)((0, class_transformer_1.plainToInstance)(instance, value), {
+        excludeExtraneousValues: true,
+        exposeUnsetFields: true,
+    });
 }
 const isClassValidatorClass = (target) => {
     try {
         const clsval = require("class-validator");
-        const result = clsval.getMetadataStorage().getTargetValidationMetadatas(target, undefined, false, false);
+        const result = clsval
+            .getMetadataStorage()
+            .getTargetValidationMetadatas(target, undefined, false, false);
         return result.length > 0;
     }
     catch (err) {
@@ -170,19 +187,19 @@ const isClassValidatorClass = (target) => {
     }
 };
 exports.isClassValidatorClass = isClassValidatorClass;
-async function validateObjectByInstance(target, value) {
+async function validateObjectByInstance(target, value = {}, options = 'array') {
     try {
         const { validateOrReject } = require("class-validator");
         const { plainToInstance } = require("class-transformer");
         await validateOrReject(plainToInstance(target, value));
     }
     catch (error) {
-        if (typeof error == 'object' && Array.isArray(error)) {
-            const errors = error.reduce((acc, x) => {
+        if (typeof error == "object" && Array.isArray(error)) {
+            const errors = options == 'object' ? error.reduce((acc, x) => {
                 //acc[x.property] = Object.values(x.constraints);
                 acc[x.property] = x.constraints;
                 return acc;
-            }, {});
+            }, {}) : error.map(x => ({ path: x.property, constraints: x.constraints }));
             return errors;
         }
         else {
@@ -190,3 +207,14 @@ async function validateObjectByInstance(target, value) {
         }
     }
 }
+function validateRequestBody(target, value, options = 'array') {
+    if (!(0, exports.isClassValidatorClass)(target))
+        return { count: 0, errors: {} };
+    const error = (0, class_validator_1.validateSync)((0, class_transformer_1.plainToInstance)(target, value ? value : {}));
+    const errors = options == 'object' ? error.reduce((acc, x) => {
+        //acc[x.property] = Object.values(x.constraints);
+        acc[x.property] = x.constraints;
+        return acc;
+    }, {}) : error.map(x => ({ path: x.property, constraints: x.constraints }));
+    return { count: error.length, errors };
+}

package/dist/icore.d.ts

@@ -1,12 +1,24 @@
-import { FastifyReply, FastifyRequest } from "fastify";
+import { FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
+import { Constructor } from "./helpers";
+import { DataSourceOptions } from "typeorm";
+import { AppMiddleware } from "./middleware";
+import { OpenApiOptions, OpenApiUiOptions } from "./openapi";
+export type FuncRoute = {
+    handler: any;
+    middlewares?: any[];
+    schema?: {};
+};
 export interface IRequest extends FastifyRequest {
     params: any;
     query: any;
     body: any;
     headers: any;
+    user?: any;
 }
 export interface IResponse extends FastifyReply {
 }
+export interface DoneFunction extends HookHandlerDoneFunction {
+}
 export interface ParamMetaOptions {
     index: number;
     key: string;
@@ -15,44 +27,76 @@ export interface ParamMetaOptions {
     validate: boolean;
     dataType: any;
     validatorClass: boolean;
-    type: "route:param" | "route:query" | "route:body" | "route:header";
+    type: "route:param" | "route:query" | "route:body" | "route:header" | "route:user";
 }
 export interface MethodParamMeta {
     params: ParamMetaOptions[];
     query: ParamMetaOptions[];
     body: ParamMetaOptions[];
     headers: ParamMetaOptions[];
+    currentUser: ParamMetaOptions[];
+    swagger?: OpenApiUiOptions;
 }
-declare class _InternalApplication {
+declare class AvleonApplication {
     private static instance;
     private static buildOptions;
     private app;
     private routeSet;
     private alreadyRun;
     private routes;
+    private middlewares;
+    private rMap;
+    private hasSwagger;
+    private globalSwaggerOptions;
+    private controllers;
     private constructor();
-    static getInternalApp(buildOptions: any): _InternalApplication;
+    static getInternalApp(buildOptions: any): AvleonApplication;
+    isDevelopment(): boolean;
+    private initSwagger;
+    useSwagger(options: OpenApiUiOptions): Promise<void>;
+    private handleMiddlewares;
+    private executeMiddlewares;
     private buildController;
     private _mapArgs;
+    private metaCache;
     private _processMeta;
-    mapControllers(): Promise<void>;
-    mapGroup(path: string): Promise<void>;
-    handleRoute(args: any): Promise<void>;
-    mapGet(path: string | undefined, fn: Function): Promise<void>;
-    mapPost(): Promise<void>;
-    mapPut(): Promise<void>;
-    mapDelete(): Promise<void>;
+    autoControllers(): Promise<void>;
+    mapControllers(controllers: Function[]): void;
     private _mapControllers;
+    mapControllersAuto(): void;
+    handleRoute(args: any): Promise<void>;
+    private mapFn;
+    useMiddlewares<T extends AppMiddleware>(mclasses: 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;
+    mapGet<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AppMiddleware>(middlewares: Constructor<AppMiddleware>[]) => /*elided*/ any;
+        useSwagger: (options: OpenApiOptions) => /*elided*/ any;
+    };
+    mapPost<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AppMiddleware>(middlewares: Constructor<AppMiddleware>[]) => /*elided*/ any;
+        useSwagger: (options: OpenApiOptions) => /*elided*/ any;
+    };
+    mapPut<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AppMiddleware>(middlewares: Constructor<AppMiddleware>[]) => /*elided*/ any;
+        useSwagger: (options: OpenApiOptions) => /*elided*/ any;
+    };
+    mapDelete<T extends (...args: any[]) => any>(path: string | undefined, fn: T): {
+        useMiddleware: <M extends AppMiddleware>(middlewares: Constructor<AppMiddleware>[]) => /*elided*/ any;
+        useSwagger: (options: OpenApiOptions) => /*elided*/ any;
+    };
     run(port?: number): Promise<void>;
 }
-export declare class AppBuilder {
+export declare class Builder {
     private static instance;
     private alreadyBuilt;
-    private databse;
+    private database;
+    private dataSource?;
     private constructor();
-    static createBuilder(): AppBuilder;
+    static createAppBuilder(): Builder;
     registerPlugin<T extends Function, S extends {}>(plugin: T, options: S): Promise<void>;
-    useDatabase(): Promise<void>;
-    build(): Promise<_InternalApplication>;
+    addDataSource(config: DataSourceOptions): Promise<void>;
+    build(): AvleonApplication;
 }
 export {};