@avleon/core 0.0.6 → 0.0.7

package/dist/icore.js

@@ -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 ||
@@ -100,13 +99,16 @@ class AvleonApplication {
         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),
         });
         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: {
@@ -174,16 +176,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({

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.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"
   }
 }