@avleon/core 0.0.4 → 0.0.6

package/dist/exceptions/http-exceptions.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotFoundException = exports.InternalErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
+exports.httpExcepitoins = exports.ForbiddenException = exports.UnauthorizedException = exports.NotFoundException = exports.InternalErrorException = exports.ValidationErrorException = exports.BadRequestException = exports.BaseHttpException = void 0;
 class BaseHttpException extends Error {
     constructor(message) {
-        super(message);
+        super(JSON.stringify(message));
         this.code = 500;
         this.name = "HttpException";
     }
@@ -20,6 +20,13 @@ class BadRequestException extends BaseHttpException {
     }
 }
 exports.BadRequestException = BadRequestException;
+class ValidationErrorException extends BadRequestException {
+    constructor() {
+        super(...arguments);
+        this.name = "ValidationError";
+    }
+}
+exports.ValidationErrorException = ValidationErrorException;
 class InternalErrorException extends BaseHttpException {
     constructor(message = "Something going wrong") {
         super(message);
@@ -36,3 +43,27 @@ class NotFoundException extends BaseHttpException {
     }
 }
 exports.NotFoundException = NotFoundException;
+class UnauthorizedException extends BaseHttpException {
+    constructor(message) {
+        super(message);
+        this.name = "Unauthorized";
+        this.code = 401;
+    }
+}
+exports.UnauthorizedException = UnauthorizedException;
+class ForbiddenException extends BaseHttpException {
+    constructor(message) {
+        super(message);
+        this.name = "Forbidden";
+        this.code = 403;
+    }
+}
+exports.ForbiddenException = ForbiddenException;
+exports.httpExcepitoins = {
+    NotFound: (message) => new NotFoundException(message),
+    ValidationError: (message) => new ValidationErrorException(message),
+    BadRequest: (message) => new BadRequestException(message),
+    Unauthorized: (message) => new UnauthorizedException(message),
+    Forbidden: (message) => new ForbiddenException(message),
+    InternalError: (message) => new InternalErrorException(message)
+};

package/dist/helpers.d.ts

@@ -1,5 +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;
@@ -21,4 +23,10 @@ export declare function jsonToJs(value: string): any;
 export declare function jsonToInstance(value: string, instance: Constructor): any;
 export declare function transformObjectByInstanceToObject(instance: Constructor, value: object): Record<string, any>;
 export declare const isClassValidatorClass: (target: Constructor) => boolean;
-export declare function validateObjectByInstance(target: Constructor, value: object): Promise<any>;
+export declare function validateObjectByInstance(target: Constructor, value?: object, options?: 'object' | 'array'): Promise<any>;
+type ValidationError = {
+    count: number;
+    errors: any;
+};
+export declare function validateRequestBody(target: Constructor, value: object, options?: 'object' | 'array'): ValidationError;
+export {};

package/dist/helpers.js

@@ -3,8 +3,9 @@ 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.isConstructor = isConstructor;
 exports.formatUrl = formatUrl;
 exports.parsedPath = parsedPath;
 exports.normalizePath = normalizePath;
@@ -17,34 +18,67 @@ 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 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');
+    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 +91,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 +114,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 +133,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 +192,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 +210,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 +230,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,25 @@
-import { FastifyReply, FastifyRequest } 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";
+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 +28,85 @@ 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 {
+type StaticFileOptions = {
+    path?: PathLike;
+    prefix?: string;
+};
+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 authorizeMiddleware?;
     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;
+    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;
+    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;
+    };
+    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 AppBuilder {
+export declare class Builder {
     private static instance;
     private alreadyBuilt;
-    private databse;
+    private database;
+    private dataSource?;
     private constructor();
-    static createBuilder(): AppBuilder;
+    static createAppBuilder(): Builder;
+    static creatTestAppBilder(): 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 {};