@avleon/core 0.0.6 → 0.0.8

package/dist/config.d.ts

@@ -1,29 +1,10 @@
-export interface IDBConfig {
-    type: string;
-    host: string;
-    port: number | string;
-    username: string;
-    password: string;
-    database: string;
-    synchronize: boolean;
-    logging: boolean;
-    entities: any[];
-    migrations?: string[];
-    subscribers?: string[];
+import { Constructable } from "typedi";
+import { Environment } from "./environment-variables";
+export interface IConfig<T = any> {
+    config(env: Environment): T;
 }
-export interface Environment extends NodeJS.ProcessEnv {
-    [key: string]: string | undefined;
+export declare function Config<T extends IConfig>(target: Constructable<T>): void;
+export declare class AppConfig {
+    get<T extends IConfig<R>, R>(configClass: Constructable<T>): R;
 }
-export interface IAppConfig {
-    apiKey: string;
-    timezone: string;
-}
-export interface IConfig {
-    config(env: Environment): object;
-}
-export declare function Config<T extends IConfig>(target: {
-    new (): T;
-}): void;
-export declare function GetConfig<T extends IConfig>(ConfigClass: {
-    new (): T;
-}): ReturnType<T["config"]>;
+export declare function GetConfig<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>['config']>>(ConfigClass: Constructable<T>): R;

package/dist/config.js

@@ -1,21 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppConfig = void 0;
 exports.Config = Config;
 exports.GetConfig = GetConfig;
-const CONFIG_METADATA_KEY = Symbol("config");
-const configInstances = new Map();
+const typedi_1 = require("typedi");
+const environment_variables_1 = require("./environment-variables");
 function Config(target) {
-    if (typeof target.prototype.config !== "function") {
-        throw new Error(`Class "${target.name}" must implement a "config" method.`);
+    typedi_1.Container.set({ id: target, type: target });
+}
+class AppConfig {
+    get(configClass) {
+        const instance = typedi_1.Container.get(configClass);
+        if (!instance) {
+            throw new Error(`Configuration for ${configClass.name} not found.`);
+        }
+        return instance.config(new environment_variables_1.Environment());
     }
-    Reflect.defineMetadata(CONFIG_METADATA_KEY, target, target);
-    // Auto-instantiate and store the config instance
-    configInstances.set(target.name, new target());
 }
+exports.AppConfig = AppConfig;
 function GetConfig(ConfigClass) {
-    const instance = configInstances.get(ConfigClass.name);
+    const instance = typedi_1.Container.get(ConfigClass);
     if (!instance) {
         throw new Error(`Class "${ConfigClass.name}" is not registered as a config.`);
     }
-    return instance.config(process.env);
+    return instance.config(new environment_variables_1.Environment());
 }

package/dist/environment-variables.d.ts

@@ -1,3 +1,5 @@
-export declare const e: Record<string, string>;
-export type Env = typeof e;
-export declare const env: Env;
+export declare class Environment {
+    private parseEnvFile;
+    get<T = any>(key: string): T;
+    getAll<T = any>(): T;
+}

package/dist/environment-variables.js

@@ -1,33 +1,47 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.env = exports.e = void 0;
+exports.Environment = void 0;
 const dotenv_1 = __importDefault(require("dotenv"));
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
+const typedi_1 = require("typedi");
+const system_exception_1 = require("./exceptions/system-exception");
 // Load environment variables
 dotenv_1.default.config({ path: path_1.default.join(process.cwd(), ".env") });
-// Read the .env file and infer keys dynamically
-const envFilePath = path_1.default.join(process.cwd(), ".env");
-const envContents = fs_1.default.readFileSync(envFilePath, "utf-8");
-// Parse .env file manually
-const parsedEnv = Object.fromEntries(envContents
-    .split("\n")
-    .filter((line) => line.trim() && !line.startsWith("#")) // Ignore empty lines and comments
-    .map((line) => {
-    const [key, ...valueParts] = line.split("="); // Split key and value
-    return [key.trim(), valueParts.join("=").trim()]; // Handle values with `=`
-}));
-const inferType = (value) => {
-    if (!isNaN(Number(value)))
-        return Number(value);
-    if (value.toLowerCase() === "true")
-        return true;
-    if (value.toLowerCase() === "false")
-        return false;
-    return value;
+let Environment = class Environment {
+    parseEnvFile(filePath) {
+        try {
+            const fileContent = fs_1.default.readFileSync(filePath, 'utf8');
+            const parsedEnv = dotenv_1.default.parse(fileContent);
+            return Object.assign(Object.assign({}, parsedEnv), process.env);
+        }
+        catch (error) {
+            console.error(`Error parsing .env file: ${error}`);
+            return {};
+        }
+    }
+    get(key) {
+        const parsedEnv = this.parseEnvFile(path_1.default.join(process.cwd(), '.env'));
+        if (!Object(parsedEnv).hasOwnProperty(key)) {
+            throw new system_exception_1.EnvironmentVariableNotFound(key);
+        }
+        return parsedEnv[key];
+    }
+    getAll() {
+        const parsedEnv = this.parseEnvFile(path_1.default.join(process.cwd(), '.env'));
+        return parsedEnv;
+    }
 };
-exports.e = parsedEnv;
-exports.env = exports.e;
+exports.Environment = Environment;
+exports.Environment = Environment = __decorate([
+    (0, typedi_1.Service)()
+], Environment);

package/dist/exceptions/system-exception.d.ts

@@ -11,3 +11,6 @@ export declare class SystemUseError extends Error {
 export declare class DuplicateRouteException extends Error {
     constructor(params: IRouteDuplicateErr);
 }
+export declare class EnvironmentVariableNotFound extends Error {
+    constructor(key: string);
+}

package/dist/exceptions/system-exception.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DuplicateRouteException = exports.SystemUseError = void 0;
+exports.EnvironmentVariableNotFound = exports.DuplicateRouteException = exports.SystemUseError = void 0;
 class SystemUseError extends Error {
     constructor(message) {
         super(message);
@@ -16,3 +16,9 @@ class DuplicateRouteException extends Error {
     }
 }
 exports.DuplicateRouteException = DuplicateRouteException;
+class EnvironmentVariableNotFound extends Error {
+    constructor(key) {
+        super(`${key} not found in environment variables.`);
+    }
+}
+exports.EnvironmentVariableNotFound = EnvironmentVariableNotFound;

package/dist/icore.d.ts

@@ -1,9 +1,11 @@
 import { FastifyInstance, FastifyReply, FastifyRequest, HookHandlerDoneFunction } from "fastify";
+import { Constructable } from "typedi";
 import { Constructor } from "./helpers";
 import { PathLike } from "fs";
 import { DataSourceOptions } from "typeorm";
 import { AppMiddleware } from "./middleware";
 import { OpenApiOptions, OpenApiUiOptions } from "./openapi";
+import { IConfig } from "./config";
 export type FuncRoute = {
     handler: any;
     middlewares?: any[];
@@ -55,10 +57,12 @@ declare class AvleonApplication {
     private globalSwaggerOptions;
     private controllers;
     private authorizeMiddleware?;
+    private appConfig;
     private constructor();
     static getInternalApp(buildOptions: any): AvleonApplication;
     isDevelopment(): boolean;
     private initSwagger;
+    useOpenApi<T extends IConfig<R>, R = ReturnType<InstanceType<Constructable<T>>['config']>>(ConfigClass: Constructable<T>, modifyConfig?: (config: R) => R): void;
     useSwagger(options: OpenApiUiOptions): Promise<void>;
     private handleMiddlewares;
     private executeMiddlewares;
@@ -104,7 +108,7 @@ export declare class Builder {
     private dataSource?;
     private constructor();
     static createAppBuilder(): Builder;
-    static creatTestAppBilder(): Builder;
+    static creatTestApplication(): Builder;
     registerPlugin<T extends Function, S extends {}>(plugin: T, options: S): Promise<void>;
     addDataSource(config: DataSourceOptions): Promise<void>;
     build(): AvleonApplication;

package/dist/icore.js

@@ -65,7 +65,7 @@ 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 config_1 = require("./config");
 const environment_variables_1 = require("./environment-variables");
 const isTsNode = process.env.TS_NODE_DEV ||
     process.env.TS_NODE_PROJECT ||
@@ -85,6 +85,7 @@ class AvleonApplication {
         this.authorizeMiddleware = undefined;
         this.metaCache = new Map();
         this.app = (0, fastify_1.default)();
+        this.appConfig = new config_1.AppConfig();
         // this.app.setValidatorCompiler(() => () => true);
     }
     static getInternalApp(buildOptions) {
@@ -97,16 +98,20 @@ class AvleonApplication {
         return AvleonApplication.instance;
     }
     isDevelopment() {
-        return environment_variables_1.env["NODE_ENV"] == "development";
+        const env = container_1.default.get(environment_variables_1.Environment);
+        return env.get("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),
         });
         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: {
@@ -118,6 +123,17 @@ class AvleonApplication {
             },
         });
     }
+    useOpenApi(ConfigClass, modifyConfig) {
+        const openApiConfig = this.appConfig.get(ConfigClass);
+        if (modifyConfig) {
+            const modifiedConfig = modifyConfig(openApiConfig);
+            this.globalSwaggerOptions = modifiedConfig;
+        }
+        else {
+            this.globalSwaggerOptions = openApiConfig;
+        }
+        this.hasSwagger = true;
+    }
     async useSwagger(options) {
         this.hasSwagger = true;
         this.globalSwaggerOptions = options;
@@ -153,7 +169,6 @@ class AvleonApplication {
                 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;
@@ -174,16 +189,6 @@ class AvleonApplication {
                 // 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 };
-                console.log(tag, ":", method, authClsMethodMeata);
-                // if (authClsMethodMeata.authorize && this.authorizeMiddleware) {
-                //   this.app.addHook('preHandler', async (req, res) => {
-                //     if (res.sent) return;
-                //     console.log(this.authorizeMiddleware)
-                //     const cls = container.get(this.authorizeMiddleware) as any;
-                //     console.log(cls)
-                //     cls.authorize(req);
-                //   })
-                // }
                 const allMeta = this._processMeta(prototype, method);
                 const routePath = methodmetaOptions.path == "" ? "/" : methodmetaOptions.path;
                 this.app.route({
@@ -306,12 +311,10 @@ class AvleonApplication {
         }
     }
     async handleRoute(args) {
-        console.log(args);
     }
     async mapFn(fn) {
         const original = fn;
         fn = function () {
-            console.log(arguments);
         };
         return fn;
     }
@@ -451,7 +454,7 @@ class AvleonApplication {
         });
         await this.app.ready();
         await this.app.listen({ port });
-        console.log(`Application running on port: 0.0.0.0:${port}`);
+        console.log(`Application running on http://127.0.0.1:${port}`);
     }
     getTestApp(app) {
         return this.app;
@@ -470,7 +473,7 @@ class Builder {
         }
         return Builder.instance;
     }
-    static creatTestAppBilder() {
+    static creatTestApplication() {
         if (!Builder.instance) {
             Builder.instance = new Builder();
         }
@@ -495,7 +498,6 @@ class Builder {
             await datasource.initialize();
         }
         catch (error) {
-            console.log(error);
             console.error("Database Initialize Error:", error.message);
         }
     }

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "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"
   }
 }