@avleon/core 0.0.12 → 0.0.14

package/dist/swagger-schema.js

@@ -7,22 +7,28 @@ exports.generateSwaggerSchema = generateSwaggerSchema;
  * @email xtrinsic96@gmail.com
  * @url https://github.com/xtareq
  */
+const class_validator_1 = require("class-validator");
 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 metadataStorage = (0, class_validator_1.getMetadataStorage)();
+    const validationMetadata = metadataStorage.getTargetValidationMetadatas(classType, "", true, false);
     const schema = {
         type: "object",
         properties: {},
         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);
+    const prototype = classType.prototype;
+    const propertyKeys = new Set([
+        ...Object.getOwnPropertyNames(prototype),
+        ...validationMetadata.map((m) => m.propertyName),
+    ]);
+    propertyKeys.forEach((propertyName) => {
+        var _a;
+        if (!propertyName || propertyName === "constructor")
+            return;
+        const openApiMeta = Reflect.getMetadata("property:openapi", prototype, propertyName);
+        if (openApiMeta === null || openApiMeta === void 0 ? void 0 : openApiMeta.exclude)
+            return;
+        const propertyType = Reflect.getMetadata("design:type", prototype, propertyName);
         let swaggerProperty = {};
         switch (propertyType) {
             case String:
@@ -39,85 +45,101 @@ function generateSwaggerSchema(classType) {
                 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
-                }
+                swaggerProperty.type = "array";
+                swaggerProperty.items = { type: "string" }; // fallback
                 break;
             case Object:
-                //Nested object
-                const nestedSchema = generateSwaggerSchema(Reflect.getMetadata("design:type", classType.prototype, propertyName));
-                swaggerProperty = nestedSchema;
+                swaggerProperty = generateSwaggerSchema(propertyType);
                 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
+                swaggerProperty.type = ((_a = propertyType === null || propertyType === void 0 ? void 0 : propertyType.name) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || "string";
+        }
+        // Apply OpenApi metadata if present
+        if (openApiMeta) {
+            swaggerProperty = Object.assign(Object.assign({}, swaggerProperty), extractOpenApiFields(openApiMeta));
         }
         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
-            }
-        });
+    });
+    // Handle validation rules
+    validationMetadata.forEach((meta) => {
+        const propertyName = meta.propertyName;
+        switch (meta.name) {
+            case "isNotEmpty":
+                if (!schema.required.includes(propertyName)) {
+                    schema.required.push(propertyName);
+                }
+                break;
+            case "isDefined":
+                if (!schema.required.includes(propertyName)) {
+                    schema.required.push(propertyName);
+                }
+                break;
+            case "isOptional":
+                schema.required = schema.required.filter((item) => item !== propertyName);
+                break;
+            case "minLength":
+                schema.properties[propertyName].minLength = meta.constraints[0];
+                break;
+            case "maxLength":
+                schema.properties[propertyName].maxLength = meta.constraints[0];
+                break;
+            case "min":
+                schema.properties[propertyName].minimum = meta.constraints[0];
+                break;
+            case "max":
+                schema.properties[propertyName].maximum = meta.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 = meta.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;
+        }
     });
     return schema;
 }
+function extractOpenApiFields(meta) {
+    const result = {};
+    const fields = [
+        "description",
+        "summary",
+        "deprecated",
+        "example",
+        "enum",
+        "format",
+        "default",
+        "minimum",
+        "maximum",
+        "minLength",
+        "maxLength",
+        "pattern",
+        "oneOf",
+        "allOf",
+        "anyOf",
+    ];
+    fields.forEach((field) => {
+        if (meta[field] !== undefined) {
+            result[field] = meta[field];
+        }
+    });
+    return result;
+}
 // export function generateSwaggerSchema(classType: any) {
 //   const { getMetadataStorage } = require("class-validator");
 //   const { plainToInstance } = require("class-transformer");

package/package.json

@@ -1,11 +1,7 @@
 {
   "name": "@avleon/core",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "main": "./dist/index.js",
-  "types": [
-    "./dist/index.d.ts",
-    "./exceptions/index.d.ts"
-  ],
   "scripts": {
     "build": "rimraf dist && tsc",
     "watch": "tsc-watch",
@@ -37,10 +33,14 @@
     "bcryptjs": "^3.0.2",
     "dotenv": "^16.4.7",
     "fastify": "^5.1.0",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.0.0",
     "reflect-metadata": "^0.2.2",
     "typedi": "^0.10.0"
   },
   "peerDependencies": {
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
     "typeorm": "^0.3.20"
   },
   "directories": {