@trapi/metadata 1.0.0-alpha.2 → 1.0.0-alpha.3

package/dist/generator/parameter/module.js

@@ -30,11 +30,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ParameterGenerator = void 0;
+const locter_1 = require("locter");
 const ts = __importStar(require("typescript"));
 const decorator_1 = require("../../decorator");
-const error_1 = require("../../error");
 const resolver_1 = require("../../resolver");
 const utils_1 = require("../../utils");
+const constants_1 = require("./constants");
+const error_1 = require("./error");
+const validator_1 = require("./validator");
 const parameterKeys = [
     decorator_1.DecoratorID.CONTEXT,
     decorator_1.DecoratorID.PARAM,
@@ -46,10 +49,10 @@ const parameterKeys = [
     decorator_1.DecoratorID.HEADERS,
     decorator_1.DecoratorID.COOKIE,
     decorator_1.DecoratorID.COOKIES,
-    decorator_1.DecoratorID.PATH_PARAM,
-    decorator_1.DecoratorID.PATH_PARAMS,
-    decorator_1.DecoratorID.FILE_PARAM,
-    decorator_1.DecoratorID.FILES_PARAM,
+    decorator_1.DecoratorID.PATH,
+    decorator_1.DecoratorID.PATHS,
+    decorator_1.DecoratorID.FILE,
+    decorator_1.DecoratorID.FILES,
 ];
 class ParameterGenerator {
     constructor(parameter, method, path, current) {
@@ -61,248 +64,314 @@ class ParameterGenerator {
     generate() {
         const decorators = (0, utils_1.getNodeDecorators)(this.parameter);
         for (let i = 0; i < parameterKeys.length; i++) {
-            const representation = this.current.decoratorResolver.match(parameterKeys[i], decorators);
-            if (typeof representation === 'undefined') {
+            const manager = this.current.decoratorResolver.match(parameterKeys[i], decorators);
+            if (typeof manager === 'undefined') {
                 continue;
             }
-            switch (representation.key) {
+            switch (manager.representation.id) {
                 case decorator_1.DecoratorID.CONTEXT:
                     return this.getContextParameter();
                 case decorator_1.DecoratorID.PARAM:
                 case decorator_1.DecoratorID.PARAMS:
-                    return this.getRequestParameter(representation);
+                    return this.getParamParameter(manager);
                 case decorator_1.DecoratorID.FORM:
-                    return this.getFormParameter(representation);
+                    return this.getFormParameter(manager);
                 case decorator_1.DecoratorID.QUERY:
-                    return this.getQueryParameter(representation);
+                    return this.getQueryParameter(manager);
                 case decorator_1.DecoratorID.BODY:
-                    return this.getBodyParameter(representation);
+                    return this.getBodyParameter(manager);
                 case decorator_1.DecoratorID.HEADER:
                 case decorator_1.DecoratorID.HEADERS:
-                    return this.getHeaderParameter(representation);
+                    return this.getHeaderParameter(manager);
                 case decorator_1.DecoratorID.COOKIE:
                 case decorator_1.DecoratorID.COOKIES:
-                    return this.getCookieParameter(representation);
-                case decorator_1.DecoratorID.PATH_PARAM:
-                case decorator_1.DecoratorID.PATH_PARAMS:
-                    return this.getPathParameter(representation);
-                case decorator_1.DecoratorID.FILE_PARAM:
-                    return this.getFileParameter(representation);
-                case decorator_1.DecoratorID.FILES_PARAM:
-                    return this.getFileParameter(representation, true);
+                    return this.getCookieParameter(manager);
+                case decorator_1.DecoratorID.PATH:
+                case decorator_1.DecoratorID.PATHS:
+                    return this.getPathParameter(manager);
+                case decorator_1.DecoratorID.FILE:
+                case decorator_1.DecoratorID.FILES:
+                    return this.getFileParameter(manager);
             }
         }
+        // todo: add BodyProp decorator, due the fact that single body parameter can contain object.
         return this.getBodyParameter();
     }
-    getCurrentLocation() {
-        const methodId = this.parameter.parent.name;
-        const controllerId = this.parameter.parent.parent.name;
-        return `${controllerId.text}.${methodId.text}`;
-    }
-    getRequestParameter(manager) {
-        const parameterName = this.parameter.name.text;
-        let name = parameterName;
-        const type = this.getValidatedType(this.parameter);
-        if (!this.supportsBodyParameters(this.method)) {
-            throw new Error(`Param can't support '${this.getCurrentLocation()}' method.`);
+    buildParametersForObject(type, details) {
+        if (type.properties.length === 0) {
+            return [];
         }
-        const value = manager.getPropertyValue('value');
-        if (typeof value === 'string') {
-            name = value;
+        const parameterName = this.parameter.name.text;
+        const initializerValue = (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type);
+        const output = [];
+        for (let i = 0; i < type.properties.length; i++) {
+            const property = type.properties[i];
+            const propertyDefaultValue = initializerValue[property.name];
+            let propertyRequired = !this.parameter.questionToken;
+            if (propertyRequired) {
+                propertyRequired = property.required;
+            }
+            output.push({
+                ...details,
+                default: property.default || propertyDefaultValue,
+                description: property.description || details.description || this.getParameterDescription(),
+                name: property.name,
+                parameterName,
+                required: propertyRequired,
+                type: property.type,
+                deprecated: property.deprecated || this.getParameterDeprecation(),
+            });
+            // todo: example, format
         }
-        return {
-            default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
-            description: this.getParameterDescription(),
-            in: 'param',
-            name: name || parameterName,
-            parameterName,
-            required: !this.parameter.questionToken,
-            type,
-            deprecated: this.getParameterDeprecation(),
-        };
+        return output;
+    }
+    getParamParameter(manager) {
+        return [
+            ...this.getBodyParameter(manager),
+            ...this.getCookieParameter(manager),
+        ];
     }
     getContextParameter() {
         const parameterName = this.parameter.name.text;
-        return {
-            description: this.getParameterDescription(),
-            in: 'context',
-            name: parameterName,
-            parameterName,
-            required: !this.parameter.questionToken,
-            type: null,
-        };
-    }
-    /*
-    private getFileParameter(parameter: ts.ParameterDeclaration): Metadata.Parameter{
-        const parameterName = (parameter.name as ts.Identifier).text;
-
-        if (!this.supportsBodyParameters(this.method)) {
-            throw new Error(`FileParam can't support '${this.getCurrentLocation()}' method.`);
-        }
-
-        return {
-            description: this.getParameterDescription(parameter),
-            in: 'formData',
-            name: getDecoratorTextValue(this.parameter, ident => ident.text === 'FileParam') || parameterName,
-            parameterName: parameterName,
-            required: !parameter.questionToken,
-            type: { typeName: 'file' }
-        };
+        // todo: req, res, next should maybe be separate parameter sources.
+        return [
+            {
+                description: this.getParameterDescription(),
+                in: constants_1.ParameterSource.CONTEXT,
+                name: parameterName,
+                parameterName,
+                required: !this.parameter.questionToken,
+                type: null,
+            },
+        ];
     }
-     */
-    getFileParameter(representationManager, isArray) {
+    getFileParameter(manager) {
         const parameterName = this.parameter.name.text;
         let name = parameterName;
-        if (!this.supportsBodyParameters(this.method)) {
-            throw new Error(`File(s)Param can't support '${this.getCurrentLocation()}' method.`);
-        }
-        const value = representationManager.getPropertyValue('value');
+        const value = manager.get('value');
         if (typeof value === 'string') {
             name = value;
         }
+        if (!this.isBodySupportedForMethod(this.method)) {
+            throw error_1.ParameterError.methodUnsupported({
+                decoratorName: manager.representation.name,
+                propertyName: name,
+                method: this.method,
+                node: this.parameter,
+            });
+        }
         const elementType = { typeName: 'file' };
         let type;
-        if (isArray) {
+        if (manager.representation.id === decorator_1.DecoratorID.FILES) {
             type = { typeName: 'array', elementType };
         }
         else {
             type = elementType;
         }
-        return {
-            default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
-            description: this.getParameterDescription(),
-            in: 'formData',
-            name: name || parameterName,
-            parameterName,
-            required: !this.parameter.questionToken && !this.parameter.initializer,
-            type,
-            deprecated: this.getParameterDeprecation(),
-        };
+        const { examples, exampleLabels } = this.getParameterExample(parameterName);
+        return [
+            {
+                default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
+                description: this.getParameterDescription(),
+                examples,
+                exampleLabels,
+                in: constants_1.ParameterSource.FORM_DATA,
+                name: name || parameterName,
+                parameterName,
+                required: !this.parameter.questionToken && !this.parameter.initializer,
+                type,
+                deprecated: this.getParameterDeprecation(),
+                validators: (0, validator_1.getParameterValidators)(this.parameter, parameterName),
+            },
+        ];
     }
-    getFormParameter(representationManager) {
+    getFormParameter(manager) {
         const parameterName = this.parameter.name.text;
         let name = parameterName;
         const type = this.getValidatedType(this.parameter);
-        if (!this.supportsBodyParameters(this.method)) {
-            throw new Error(`Form can't support '${this.getCurrentLocation()}' method.`);
+        if (!this.isBodySupportedForMethod(this.method)) {
+            throw error_1.ParameterError.methodUnsupported({
+                decoratorName: manager.representation.name,
+                propertyName: name,
+                method: this.method,
+                node: this.parameter,
+            });
         }
-        const value = representationManager.getPropertyValue('value');
+        const value = manager.get('value');
         if (typeof value === 'string') {
             name = value;
         }
-        return {
-            default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
-            description: this.getParameterDescription(),
-            in: 'formData',
-            name: name || parameterName,
-            parameterName,
-            required: !this.parameter.questionToken && !this.parameter.initializer,
-            type,
-            deprecated: this.getParameterDeprecation(),
-        };
+        const { examples, exampleLabels } = this.getParameterExample(parameterName);
+        return [
+            {
+                default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
+                description: this.getParameterDescription(),
+                examples,
+                exampleLabels,
+                in: constants_1.ParameterSource.FORM_DATA,
+                name: name || parameterName,
+                parameterName,
+                required: !this.parameter.questionToken && !this.parameter.initializer,
+                type,
+                deprecated: this.getParameterDeprecation(),
+                validators: (0, validator_1.getParameterValidators)(this.parameter, parameterName),
+            },
+        ];
     }
     getCookieParameter(manager) {
         const parameterName = this.parameter.name.text;
         let name = parameterName;
         const type = this.getValidatedType(this.parameter);
-        if (!this.supportPathDataType(type)) {
-            throw new Error(`Cookie can't support '${this.getCurrentLocation()}' method.`);
+        const { examples, exampleLabels } = this.getParameterExample(parameterName);
+        if (type.typeName === 'nestedObjectLiteral' ||
+            type.typeName === 'refObject') {
+            return this.buildParametersForObject(type, {
+                in: constants_1.ParameterSource.COOKIE,
+                examples,
+                exampleLabels,
+            });
+        }
+        if (!this.isTypeSupported(type)) {
+            throw error_1.ParameterError.typeUnsupported({
+                decoratorName: manager.representation.name,
+                propertyName: name,
+                type,
+                node: this.parameter,
+            });
         }
-        const value = manager.getPropertyValue('value');
+        const value = manager.get('value');
         if (typeof value === 'string') {
             name = value;
         }
-        return {
-            default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
-            description: this.getParameterDescription(),
-            in: 'cookie',
-            name: name || parameterName,
-            parameterName,
-            required: !this.parameter.questionToken && !this.parameter.initializer,
-            type,
-            deprecated: this.getParameterDeprecation(),
-        };
+        return [
+            {
+                default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
+                description: this.getParameterDescription(),
+                examples,
+                exampleLabels,
+                in: constants_1.ParameterSource.COOKIE,
+                name: name || parameterName,
+                parameterName,
+                required: !this.parameter.questionToken && !this.parameter.initializer,
+                type,
+                deprecated: this.getParameterDeprecation(),
+                validators: (0, validator_1.getParameterValidators)(this.parameter, parameterName),
+            },
+        ];
     }
     getBodyParameter(manager) {
         const parameterName = this.parameter.name.text;
         let name = parameterName;
-        const type = this.getValidatedType(this.parameter);
-        if (!this.supportsBodyParameters(this.method)) {
-            throw new Error(`Body can't support ${this.method} method`);
-        }
-        if (typeof manager !== 'undefined') {
-            const value = manager.getPropertyValue('value');
+        let source = constants_1.ParameterSource.BODY;
+        if (manager) {
+            const value = manager.get('value');
             if (typeof value === 'string') {
                 name = value;
+                source = constants_1.ParameterSource.BODY_PROP;
             }
         }
-        return {
-            default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
-            description: this.getParameterDescription(),
-            in: 'body',
-            name: name || parameterName,
-            parameterName,
-            required: !this.parameter.questionToken && !this.parameter.initializer,
-            type,
-            deprecated: this.getParameterDeprecation(),
-        };
+        const type = this.getValidatedType(this.parameter);
+        if (!this.isBodySupportedForMethod(this.method)) {
+            throw error_1.ParameterError.methodUnsupported({
+                decoratorName: manager ? manager.representation.name : 'Body',
+                propertyName: name,
+                method: this.method,
+                node: this.parameter,
+            });
+        }
+        const { examples, exampleLabels } = this.getParameterExample(parameterName);
+        return [
+            {
+                default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
+                description: this.getParameterDescription(),
+                examples,
+                exampleLabels,
+                in: source,
+                name: name || parameterName,
+                parameterName,
+                required: !this.parameter.questionToken && !this.parameter.initializer,
+                type,
+                deprecated: this.getParameterDeprecation(),
+                validators: (0, validator_1.getParameterValidators)(this.parameter, parameterName),
+            },
+        ];
     }
     getHeaderParameter(manager) {
         const parameterName = this.parameter.name.text;
         let name = parameterName;
         const type = this.getValidatedType(this.parameter);
-        if (!this.supportPathDataType(type)) {
-            throw new error_1.InvalidParameterException(`Parameter '${parameterName}' can't be passed as a header parameter in '${this.getCurrentLocation()}'.`);
-        }
-        const value = manager.getPropertyValue('value');
+        const value = manager.get('value');
         if (typeof value === 'string') {
             name = value;
         }
-        return {
-            default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
-            description: this.getParameterDescription(),
-            in: 'header',
-            name: name || parameterName,
-            parameterName,
-            required: !this.parameter.questionToken && !this.parameter.initializer,
-            type,
-            deprecated: this.getParameterDeprecation(),
-        };
+        const { examples, exampleLabels } = this.getParameterExample(parameterName);
+        if (type.typeName === 'nestedObjectLiteral' || type.typeName === 'refObject') {
+            return this.buildParametersForObject(type, {
+                in: constants_1.ParameterSource.HEADER,
+                examples,
+                exampleLabels,
+            });
+        }
+        if (!this.isTypeSupported(type)) {
+            throw error_1.ParameterError.typeUnsupported({
+                decoratorName: manager.representation.name,
+                propertyName: name,
+                type,
+                node: this.parameter,
+            });
+        }
+        return [
+            {
+                default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
+                description: this.getParameterDescription(),
+                examples,
+                exampleLabels,
+                in: constants_1.ParameterSource.HEADER,
+                name: name || parameterName,
+                parameterName,
+                required: !this.parameter.questionToken && !this.parameter.initializer,
+                type,
+                deprecated: this.getParameterDeprecation(),
+                validators: (0, validator_1.getParameterValidators)(this.parameter, parameterName),
+            },
+        ];
     }
-    getQueryParameter(representationManager) {
+    getQueryParameter(manager) {
         const parameterName = this.parameter.name.text;
         const type = this.getValidatedType(this.parameter);
-        if (!this.supportQueryDataType(type)) {
-            /*
-            const arrayType = getCommonPrimitiveAndArrayUnionType(parameter.type);
-            if (arrayType && this.supportQueryDataType(arrayType)) {
-                type = arrayType;
-            } else {
-                throw new InvalidParameterException(
-                `Parameter '${parameterName}' can't be passed as a query parameter in '${this.getCurrentLocation()}'.`
-                );
-            }
-             */
-            // throw new InvalidParameterException(
-            // `Parameter '${parameterName}' can't be passed as a query parameter in '${this.getCurrentLocation()}'.`
-            // );
-        }
         let name = parameterName;
         let options = {};
-        const nameValue = representationManager.getPropertyValue('value');
+        let source = constants_1.ParameterSource.QUERY;
+        const nameValue = manager.get('value');
         if (typeof nameValue === 'string') {
             name = nameValue;
+            source = constants_1.ParameterSource.QUERY_PROP;
         }
-        const optionsValue = representationManager.getPropertyValue('options');
-        if (typeof optionsValue !== 'undefined') {
+        const optionsValue = manager.get('options');
+        if ((0, locter_1.isObject)(optionsValue)) {
             options = optionsValue;
         }
+        const { examples, exampleLabels } = this.getParameterExample(parameterName);
+        if (source === constants_1.ParameterSource.QUERY) {
+            // yeah! we can transform the object to individual properties.
+            if (type.typeName === 'nestedObjectLiteral' ||
+                type.typeName === 'refObject') {
+                return this.buildParametersForObject(type, {
+                    in: constants_1.ParameterSource.QUERY_PROP,
+                    examples,
+                    exampleLabels,
+                });
+                // todo: transform ( type.typeName === 'array')
+            }
+        }
         const properties = {
             allowEmptyValue: options.allowEmptyValue,
             collectionFormat: options.collectionFormat,
             default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
             description: this.getParameterDescription(),
-            in: 'query',
+            examples,
+            exampleLabels,
+            in: source,
             maxItems: options.maxItems,
             minItems: options.minItems,
             name,
@@ -310,41 +379,101 @@ class ParameterGenerator {
             required: !this.parameter.questionToken && !this.parameter.initializer,
             type,
             deprecated: this.getParameterDeprecation(),
+            validators: (0, validator_1.getParameterValidators)(this.parameter, parameterName),
         };
         if (type.typeName === 'array') {
-            return {
-                ...properties,
-                collectionFormat: 'multi',
+            if (!this.isTypeSupported(type.elementType)) {
+                throw error_1.ParameterError.typeUnsupported({
+                    decoratorName: manager.representation.name,
+                    propertyName: name,
+                    type: type.elementType,
+                    node: this.parameter,
+                });
+            }
+            return [{
+                    ...properties,
+                    collectionFormat: constants_1.CollectionFormat.MULTI,
+                    type,
+                }];
+        }
+        // todo: investigate if this refEnum and union are valid types
+        if (!this.isTypeSupportedForQueryParameter(type)) {
+            throw error_1.ParameterError.typeUnsupported({
+                decoratorName: manager.representation.name,
+                propertyName: name,
                 type,
-            };
+                node: this.parameter,
+            });
         }
-        return properties;
+        return [properties];
+    }
+    isTypeSupportedForQueryParameter(type) {
+        return this.isTypeSupported(type) ||
+            type.typeName === 'refEnum' ||
+            type.typeName === 'union';
     }
     getPathParameter(manager) {
         const parameterName = this.parameter.name.text;
-        let pathName = parameterName;
+        let name = parameterName;
         const type = this.getValidatedType(this.parameter);
-        const value = manager.getPropertyValue('value');
+        const value = manager.get('value');
         if (typeof value === 'string') {
-            pathName = value;
+            name = value;
         }
-        if (!this.supportPathDataType(type)) {
-            throw new error_1.InvalidParameterException(`Parameter '${parameterName}:${type.typeName}' can't be passed as a path parameter in '${this.getCurrentLocation()}'.`);
+        const { examples, exampleLabels } = this.getParameterExample(parameterName);
+        if (type.typeName === 'nestedObjectLiteral' || type.typeName === 'refObject') {
+            const output = this.buildParametersForObject(type, {
+                in: constants_1.ParameterSource.PATH,
+                examples,
+                exampleLabels,
+            });
+            for (let i = 0; i < output.length; i++) {
+                if ((!this.path.includes(`{${output[i].name}}`)) &&
+                    (!this.path.includes(`:${output[i].name}`))) {
+                    throw error_1.ParameterError.invalidPathMatch({
+                        decoratorName: manager.representation.name,
+                        propertyName: name,
+                        path: this.path,
+                        node: this.parameter,
+                    });
+                }
+            }
+            return output;
         }
-        if ((!this.path.includes(`{${pathName}}`)) && (!this.path.includes(`:${pathName}`))) {
-            throw new Error(`Parameter '${parameterName}' can't match in path: '${this.path}'`);
+        if (!this.isTypeSupported(type)) {
+            throw error_1.ParameterError.typeUnsupported({
+                decoratorName: manager.representation.name,
+                propertyName: name,
+                type,
+                node: this.parameter,
+            });
         }
-        return {
-            default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
-            description: this.getParameterDescription(),
-            in: 'path',
-            name: pathName,
-            parameterName,
-            required: true,
-            type,
-            deprecated: this.getParameterDeprecation(),
-        };
+        if ((!this.path.includes(`{${name}}`)) &&
+            (!this.path.includes(`:${name}`))) {
+            throw error_1.ParameterError.invalidPathMatch({
+                decoratorName: manager.representation.name,
+                propertyName: name,
+                path: this.path,
+                node: this.parameter,
+            });
+        }
+        return [
+            {
+                default: (0, utils_1.getInitializerValue)(this.parameter.initializer, this.current.typeChecker, type),
+                description: this.getParameterDescription(),
+                examples,
+                exampleLabels,
+                in: constants_1.ParameterSource.PATH,
+                name: name || parameterName,
+                parameterName,
+                required: true,
+                type,
+                deprecated: this.getParameterDeprecation(),
+                validators: (0, validator_1.getParameterValidators)(this.parameter, parameterName),
+            },
+        ];
     }
+    // -------------------------------------------------------------------------------------
     getParameterDescription() {
         const symbol = this.current.typeChecker.getSymbolAtLocation(this.parameter.name);
         if (symbol) {
@@ -359,19 +488,56 @@ class ParameterGenerator {
         if ((0, utils_1.hasJSDocTag)(this.parameter, utils_1.JSDocTagName.DEPRECATED)) {
             return true;
         }
-        const decorators = (0, utils_1.getNodeDecorators)(this.parameter, (identifier) => identifier.text === 'Deprecated');
-        return decorators.length > 0;
+        const match = this.current.decoratorResolver.match(decorator_1.DecoratorID.DEPRECATED, this.parameter);
+        return !!match;
     }
-    supportsBodyParameters(method) {
-        return ['delete', 'post', 'put', 'patch', 'get'].some((m) => m === method);
+    getParameterExample(parameterName) {
+        const exampleLabels = [];
+        const examples = (0, utils_1.getJSDocTags)(this.parameter.parent, (tag) => {
+            const comment = (0, utils_1.transformJSDocComment)(tag.comment);
+            const isExample = (tag.tagName.text === utils_1.JSDocTagName.EXAMPLE || tag.tagName.escapedText === utils_1.JSDocTagName.EXAMPLE) &&
+                !!comment && comment.startsWith(parameterName);
+            if (isExample && comment) {
+                const hasExampleLabel = (comment.split(' ')[0].indexOf('.') || -1) > 0;
+                // custom example label is delimited by first '.' and the rest will all be included as example label
+                exampleLabels.push(hasExampleLabel ? comment.split(' ')[0].split('.').slice(1).join('.') : undefined);
+            }
+            return isExample ?? false;
+        }).map((tag) => ((0, utils_1.transformJSDocComment)(tag.comment) || '')
+            .replace(`${(0, utils_1.transformJSDocComment)(tag.comment)?.split(' ')[0] || ''}`, '')
+            .replace(/\r/g, ''));
+        if (examples.length === 0) {
+            return {
+                examples: undefined,
+                exampleLabels: undefined,
+            };
+        }
+        try {
+            return {
+                examples: examples.map((example) => JSON.parse(example)),
+                exampleLabels,
+            };
+        }
+        catch (e) {
+            throw error_1.ParameterError.invalidExampleSchema();
+        }
     }
-    supportPathDataType(parameterType) {
-        return ['string', 'integer', 'long', 'float', 'double', 'date', 'datetime', 'buffer', 'boolean', 'enum'].find((t) => t === parameterType.typeName);
+    isBodySupportedForMethod(method) {
+        return ['delete', 'post', 'put', 'patch', 'get'].some((m) => m === method);
     }
-    supportQueryDataType(parameterType) {
-        // Copied from supportPathDataType and added 'array'. Not sure if all options apply to queries, but kept to avoid breaking change.
-        return ['string', 'integer', 'long', 'float', 'double', 'date',
-            'datetime', 'buffer', 'boolean', 'enum', 'array', 'object'].find((t) => t === parameterType.typeName);
+    isTypeSupported(parameterType) {
+        return [
+            'string',
+            'integer',
+            'long',
+            'float',
+            'double',
+            'date',
+            'datetime',
+            'buffer',
+            'boolean',
+            'enum',
+        ].find((t) => t === parameterType.typeName);
     }
     getValidatedType(parameter) {
         let typeNode = parameter.type;