@midwayjs/swagger 4.0.0-beta.12 → 4.0.0-beta.14

package/dist/config/config.default.js

@@ -14,5 +14,6 @@ exports.swagger = {
         : render_1.renderSwaggerUIRemote,
     swaggerUIRenderOptions: {},
     isGenerateTagForController: true,
+    useValidationSchema: true,
 };
 //# sourceMappingURL=config.default.js.map

package/dist/interfaces/index.d.ts

@@ -381,6 +381,12 @@ export interface SwaggerOptions {
      * Weather to generate the Tag for controller
      */
     isGenerateTagForController?: boolean;
+    /**
+     * Enable inferring schema metadata from @midwayjs/validation DTO rules.
+     * When enabled, inferred metadata only fills fields that are not explicitly
+     * defined by @ApiProperty.
+     */
+    useValidationSchema?: boolean;
 }
 export interface MixDecoratorMetadata {
     key: string;

package/dist/swaggerExplorer.d.ts

@@ -52,6 +52,11 @@ export declare class SwaggerExplorer {
      * @param clzz
      */
     protected parseClzz(clzz: Type): any;
+    private mergePropertyMetadata;
+    protected getValidationSchemaHelper(): any;
+    private inferValidationProperties;
+    private inferValidateProperties;
+    protected hasClassValidatorMetadata(clzz: Type): boolean;
     /**
      * 授权验证
      * @param opts

package/dist/swaggerExplorer.js

@@ -15,6 +15,8 @@ const constants_1 = require("./constants");
 const documentBuilder_1 = require("./documentBuilder");
 const _1 = require(".");
 const enum_utils_1 = require("./common/enum.utils");
+const VALIDATION_RULES_KEY = 'validation:rules';
+const VALIDATE_RULES_KEY = 'common:rules';
 let SwaggerExplorer = class SwaggerExplorer {
     swaggerConfig = {};
     documentBuilder = new documentBuilder_1.DocumentBuilder();
@@ -774,6 +776,18 @@ let SwaggerExplorer = class SwaggerExplorer {
         for (const key in props) {
             props[key] = props[key][props[key].length - 1];
         }
+        if (this.swaggerConfig?.useValidationSchema) {
+            const inferredProps = this.inferValidationProperties(clzz);
+            for (const key of Object.keys(inferredProps)) {
+                if (!props[key]) {
+                    props[key] = inferredProps[key];
+                    continue;
+                }
+                const existingMeta = props[key].metadata || {};
+                const inferredMeta = inferredProps[key].metadata || {};
+                props[key].metadata = this.mergePropertyMetadata(existingMeta, inferredMeta);
+            }
+        }
         const tt = {
             type: 'object',
             properties: {},
@@ -845,6 +859,120 @@ let SwaggerExplorer = class SwaggerExplorer {
         // just for test
         return tt;
     }
+    mergePropertyMetadata(swaggerMetadata, inferredMetadata) {
+        const mergedMetadata = { ...swaggerMetadata };
+        const fillableKeys = [
+            'type',
+            'items',
+            'format',
+            'enum',
+            '$ref',
+            'pattern',
+            'default',
+        ];
+        for (const key of fillableKeys) {
+            if (mergedMetadata[key] === undefined &&
+                inferredMetadata[key] !== undefined) {
+                mergedMetadata[key] = inferredMetadata[key];
+            }
+        }
+        if (mergedMetadata.required === undefined &&
+            inferredMetadata.required !== undefined) {
+            mergedMetadata.required = inferredMetadata.required;
+        }
+        return mergedMetadata;
+    }
+    getValidationSchemaHelper() {
+        try {
+            const validationPkg = (0, core_1.safeRequire)('@midwayjs/validation');
+            const registry = validationPkg?.registry;
+            if (!registry?.getDefaultValidator) {
+                return;
+            }
+            return registry.getDefaultValidator()?.schemaHelper;
+        }
+        catch {
+            // When @midwayjs/validate and @midwayjs/validation are both installed in
+            // the same process, loading validation package may throw duplicated error
+            // group exceptions. Swagger should degrade gracefully in this case.
+            return;
+        }
+    }
+    inferValidationProperties(clzz) {
+        const ruleProps = core_1.MetadataManager.getPropertiesWithMetadata(VALIDATION_RULES_KEY, clzz) ||
+            {};
+        const hasRuleMetadata = Object.keys(ruleProps).length > 0;
+        const validateRuleProps = core_1.MetadataManager.getPropertiesWithMetadata(VALIDATE_RULES_KEY, clzz) || {};
+        const hasValidateRuleMetadata = Object.keys(validateRuleProps).length > 0;
+        const hasClassValidatorMetadata = this.hasClassValidatorMetadata(clzz);
+        if (!hasRuleMetadata &&
+            !hasClassValidatorMetadata &&
+            !hasValidateRuleMetadata) {
+            return {};
+        }
+        const inferredProps = {};
+        if (hasRuleMetadata || hasClassValidatorMetadata) {
+            const schemaHelper = this.getValidationSchemaHelper();
+            if (schemaHelper &&
+                typeof schemaHelper.getSwaggerPropertyKeys === 'function' &&
+                typeof schemaHelper.getSwaggerPropertyMetadata === 'function') {
+                const propertyKeys = schemaHelper.getSwaggerPropertyKeys(clzz) || [];
+                for (const key of propertyKeys) {
+                    const metadata = schemaHelper.getSwaggerPropertyMetadata(clzz, key);
+                    if (metadata) {
+                        inferredProps[key] = {
+                            metadata,
+                        };
+                    }
+                }
+            }
+        }
+        if (hasValidateRuleMetadata) {
+            const validateInferredProps = this.inferValidateProperties(clzz);
+            for (const [key, value] of Object.entries(validateInferredProps)) {
+                if (!inferredProps[key]) {
+                    inferredProps[key] = value;
+                    continue;
+                }
+                const mergedMetadata = this.mergePropertyMetadata(inferredProps[key].metadata || {}, value.metadata || {});
+                inferredProps[key] = {
+                    metadata: mergedMetadata,
+                };
+            }
+        }
+        return inferredProps;
+    }
+    inferValidateProperties(clzz) {
+        const inferredProps = {};
+        const ruleProps = core_1.MetadataManager.getPropertiesWithMetadata(VALIDATE_RULES_KEY, clzz) || {};
+        for (const key of Object.keys(ruleProps)) {
+            let schema = ruleProps[key];
+            if (typeof schema === 'function') {
+                schema = schema();
+            }
+            const metadata = inferJoiPropertyMetadata(schema);
+            if (metadata) {
+                inferredProps[key] = {
+                    metadata,
+                };
+            }
+        }
+        return inferredProps;
+    }
+    hasClassValidatorMetadata(clzz) {
+        try {
+            const classValidator = (0, core_1.safeRequire)('class-validator-multi-lang-lite');
+            const storage = classValidator?.getMetadataStorage?.();
+            if (!storage?.getTargetValidationMetadatas) {
+                return false;
+            }
+            const metadatas = storage.getTargetValidationMetadatas(clzz, '', false, false) || [];
+            return metadatas.length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * 授权验证
      * @param opts
@@ -962,6 +1090,47 @@ function convertSchemaType(value) {
             return 'object';
     }
 }
+function inferJoiPropertyMetadata(schema) {
+    if (!schema || typeof schema.describe !== 'function') {
+        return null;
+    }
+    const desc = schema.describe();
+    if (!desc || typeof desc !== 'object') {
+        return null;
+    }
+    const typeMap = {
+        string: 'string',
+        number: 'number',
+        boolean: 'boolean',
+        array: 'array',
+        date: 'string',
+        object: 'object',
+    };
+    const metadata = {
+        type: typeMap[desc.type] || 'object',
+    };
+    if (desc?.flags?.presence === 'required') {
+        metadata.required = true;
+    }
+    else if (desc?.flags?.presence === 'optional' || !desc?.flags?.presence) {
+        metadata.required = false;
+    }
+    if (desc.type === 'array' && Array.isArray(desc.items)) {
+        metadata.items = {
+            type: typeMap[desc.items[0]?.type] || 'object',
+        };
+    }
+    if (desc.type === 'date') {
+        metadata.format = 'date-time';
+    }
+    if (Array.isArray(desc.allow)) {
+        const enumValues = desc.allow.filter(item => item !== '' && item !== null && item !== undefined);
+        if (enumValues.length > 0) {
+            metadata.enum = enumValues;
+        }
+    }
+    return metadata;
+}
 function getNotEmptyValue(...args) {
     for (const arg of args) {
         if (arg) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/swagger",
-  "version": "4.0.0-beta.12",
+  "version": "4.0.0-beta.14",
   "description": "Midway Component for Swagger API Documentation",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -12,10 +12,10 @@
   ],
   "devDependencies": {
     "@apidevtools/swagger-parser": "11.0.1",
-    "@midwayjs/core": "^4.0.0-beta.12",
-    "@midwayjs/koa": "^4.0.0-beta.12",
-    "@midwayjs/mock": "^4.0.0-beta.12",
-    "@midwayjs/validate": "^4.0.0-beta.12",
+    "@midwayjs/core": "^4.0.0-beta.14",
+    "@midwayjs/koa": "^4.0.0-beta.14",
+    "@midwayjs/mock": "^4.0.0-beta.14",
+    "@midwayjs/validate": "^4.0.0-beta.14",
     "swagger-ui-dist": "5.18.3"
   },
   "author": "Kurten Chan <chinkurten@gmail.com>",
@@ -30,5 +30,5 @@
     "type": "git",
     "url": "https://github.com/midwayjs/midway.git"
   },
-  "gitHead": "1c48179b7c827ba8ec9351e9b6c36ec1726d3e11"
+  "gitHead": "52335cb1baa00754fffd48487f6153a3b2f1f50a"
 }