nestjs-openapi-next 1.0.0

package/dist/services/decorators-properties.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoratorsProperties = exports.decoratorsPropertiesMappingType = void 0;
+var decoratorsPropertiesMappingType;
+(function (decoratorsPropertiesMappingType) {
+    decoratorsPropertiesMappingType[decoratorsPropertiesMappingType["DIRECT"] = 0] = "DIRECT";
+    decoratorsPropertiesMappingType[decoratorsPropertiesMappingType["INDIRECT_VALUE"] = 1] = "INDIRECT_VALUE";
+    decoratorsPropertiesMappingType[decoratorsPropertiesMappingType["INDIRECT_ARGUMENT"] = 2] = "INDIRECT_ARGUMENT";
+})(decoratorsPropertiesMappingType || (exports.decoratorsPropertiesMappingType = decoratorsPropertiesMappingType = {}));
+exports.decoratorsProperties = [
+    {
+        mappingType: decoratorsPropertiesMappingType.DIRECT,
+        decorator: 'Min',
+        property: 'minimum',
+        value: undefined
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.DIRECT,
+        decorator: 'Max',
+        property: 'maximum',
+        value: undefined
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.DIRECT,
+        decorator: 'MinLength',
+        property: 'minLength',
+        value: undefined
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.DIRECT,
+        decorator: 'MaxLength',
+        property: 'maxLength',
+        value: undefined
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'ArrayNotEmpty',
+        property: 'minItems',
+        value: 1
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsPositive',
+        property: 'minimum',
+        value: 1
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsNegative',
+        property: 'maximum',
+        value: -1
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'ArrayUnique',
+        property: 'uniqueItems',
+        value: true
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsBase64',
+        property: 'format',
+        value: 'base64'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsCreditCard',
+        property: 'format',
+        value: 'credit-card'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsCurrency',
+        property: 'format',
+        value: 'currency'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsEmail',
+        property: 'format',
+        value: 'email'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsJSON',
+        property: 'format',
+        value: 'json'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsUrl',
+        property: 'format',
+        value: 'uri'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsUUID',
+        property: 'format',
+        value: 'uuid'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsMobilePhone',
+        property: 'format',
+        value: 'mobile-phone'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsAscii',
+        property: 'pattern',
+        value: '^[\\x00-\\x7F]+$'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsHexColor',
+        property: 'pattern',
+        value: '^#?([0-9A-F]{3}|[0-9A-F]{4}|[0-9A-F]{6}|[0-9A-F]{8})$'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_VALUE,
+        decorator: 'IsHexadecimal',
+        property: 'pattern',
+        value: '^(0x|0h)?[0-9A-F]+$'
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_ARGUMENT,
+        decorator: 'ArrayMinSize',
+        property: 'minItems',
+        value: undefined
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_ARGUMENT,
+        decorator: 'ArrayMaxSize',
+        property: 'maxItems',
+        value: undefined
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_ARGUMENT,
+        decorator: 'IsDivisibleBy',
+        property: 'multipleOf',
+        value: undefined
+    },
+    {
+        mappingType: decoratorsPropertiesMappingType.INDIRECT_ARGUMENT,
+        decorator: 'Contains',
+        property: 'pattern',
+        value: undefined
+    }
+];

package/dist/services/mimetype-content-wrapper.d.ts

@@ -0,0 +1,4 @@
+import { ContentObject } from '../interfaces/open-api-spec.interface';
+export declare class MimetypeContentWrapper {
+    wrap(mimetype: string[], obj: Record<string, any>): Record<'content', ContentObject>;
+}

package/dist/services/mimetype-content-wrapper.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MimetypeContentWrapper = void 0;
+const remove_undefined_keys_1 = require("../utils/remove-undefined-keys");
+class MimetypeContentWrapper {
+    wrap(mimetype, obj) {
+        const content = mimetype.reduce((acc, item) => (Object.assign(Object.assign({}, acc), { [item]: (0, remove_undefined_keys_1.removeUndefinedKeys)(obj) })), {});
+        return { content };
+    }
+}
+exports.MimetypeContentWrapper = MimetypeContentWrapper;

package/dist/services/model-properties-accessor.d.ts

@@ -0,0 +1,6 @@
+import { Type } from '@nestjs/common';
+import 'reflect-metadata';
+export declare class ModelPropertiesAccessor {
+    getModelProperties(prototype: Type<unknown>): string[];
+    applyMetadataFactory(prototype: Type<unknown>): void;
+}

package/dist/services/model-properties-accessor.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelPropertiesAccessor = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+require("reflect-metadata");
+const constants_1 = require("../constants");
+const api_property_decorator_1 = require("../decorators/api-property.decorator");
+const plugin_constants_1 = require("../plugin/plugin-constants");
+class ModelPropertiesAccessor {
+    getModelProperties(prototype) {
+        const properties = Reflect.getMetadata(constants_1.DECORATORS.API_MODEL_PROPERTIES_ARRAY, prototype) ||
+            [];
+        return properties
+            .filter(shared_utils_1.isString)
+            .filter((key) => key.charAt(0) === ':' && !(0, shared_utils_1.isFunction)(prototype[key]))
+            .map((key) => key.slice(1));
+    }
+    applyMetadataFactory(prototype) {
+        const classPrototype = prototype;
+        do {
+            if (!prototype.constructor) {
+                return;
+            }
+            if (!prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]) {
+                continue;
+            }
+            const metadata = prototype.constructor[plugin_constants_1.METADATA_FACTORY_NAME]();
+            const properties = Object.keys(metadata);
+            properties.forEach((key) => {
+                (0, api_property_decorator_1.createApiPropertyDecorator)(metadata[key], false)(classPrototype, key);
+            });
+        } while ((prototype = Reflect.getPrototypeOf(prototype)) &&
+            prototype !== Object.prototype &&
+            prototype);
+    }
+}
+exports.ModelPropertiesAccessor = ModelPropertiesAccessor;

package/dist/services/parameter-metadata-accessor.d.ts

@@ -0,0 +1,22 @@
+import { Type } from '@nestjs/common';
+import { EnumSchemaAttributes } from '../interfaces/enum-schema-attributes.interface';
+import { ParameterLocation, SchemaObject } from '../interfaces/open-api-spec.interface';
+export interface ParamWithTypeMetadata {
+    name?: string | number | object;
+    type?: Type<unknown>;
+    in?: ParameterLocation | 'body' | typeof PARAM_TOKEN_PLACEHOLDER;
+    isArray?: boolean;
+    items?: SchemaObject;
+    required?: boolean;
+    enum?: unknown[];
+    enumName?: string;
+    enumSchema?: EnumSchemaAttributes;
+    selfRequired?: boolean;
+}
+export type ParamsWithType = Record<string, ParamWithTypeMetadata>;
+declare const PARAM_TOKEN_PLACEHOLDER = "placeholder";
+export declare class ParameterMetadataAccessor {
+    explore(instance: object, prototype: Type<unknown>, method: Function): ParamsWithType;
+    private mapParamType;
+}
+export {};

package/dist/services/parameter-metadata-accessor.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParameterMetadataAccessor = void 0;
+const constants_1 = require("@nestjs/common/constants");
+const route_paramtypes_enum_1 = require("@nestjs/common/enums/route-paramtypes.enum");
+const lodash_1 = require("lodash");
+const reverse_object_keys_util_1 = require("../utils/reverse-object-keys.util");
+const PARAM_TOKEN_PLACEHOLDER = 'placeholder';
+class ParameterMetadataAccessor {
+    explore(instance, prototype, method) {
+        const types = Reflect.getMetadata(constants_1.PARAMTYPES_METADATA, instance, method.name);
+        if (!(types === null || types === void 0 ? void 0 : types.length)) {
+            return undefined;
+        }
+        const routeArgsMetadata = Reflect.getMetadata(constants_1.ROUTE_ARGS_METADATA, instance.constructor, method.name) || {};
+        const parametersWithType = (0, lodash_1.mapValues)((0, reverse_object_keys_util_1.reverseObjectKeys)(routeArgsMetadata), (param) => ({
+            type: types[param.index],
+            name: param.data,
+            required: true
+        }));
+        const excludePredicate = (val) => val.in === PARAM_TOKEN_PLACEHOLDER || (val.name && val.in === 'body');
+        const parameters = (0, lodash_1.omitBy)((0, lodash_1.mapValues)(parametersWithType, (val, key) => (Object.assign(Object.assign({}, val), { in: this.mapParamType(key) }))), excludePredicate);
+        return !(0, lodash_1.isEmpty)(parameters) ? parameters : undefined;
+    }
+    mapParamType(key) {
+        const keyPair = key.split(':');
+        switch (Number(keyPair[0])) {
+            case route_paramtypes_enum_1.RouteParamtypes.BODY:
+                return 'body';
+            case route_paramtypes_enum_1.RouteParamtypes.PARAM:
+                return 'path';
+            case route_paramtypes_enum_1.RouteParamtypes.QUERY:
+                return 'query';
+            case route_paramtypes_enum_1.RouteParamtypes.HEADERS:
+                return 'header';
+            default:
+                return PARAM_TOKEN_PLACEHOLDER;
+        }
+    }
+}
+exports.ParameterMetadataAccessor = ParameterMetadataAccessor;

package/dist/services/parameters-metadata-mapper.d.ts

@@ -0,0 +1,9 @@
+import { Type } from '@nestjs/common';
+import { ModelPropertiesAccessor } from './model-properties-accessor';
+import { ParamWithTypeMetadata, ParamsWithType } from './parameter-metadata-accessor';
+export declare class ParametersMetadataMapper {
+    private readonly modelPropertiesAccessor;
+    constructor(modelPropertiesAccessor: ModelPropertiesAccessor);
+    transformModelToProperties(parameters: ParamsWithType): ParamWithTypeMetadata[];
+    mergeImplicitWithExplicit(key: string, prototype: Type<unknown>, param: ParamWithTypeMetadata): ParamWithTypeMetadata;
+}

package/dist/services/parameters-metadata-mapper.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametersMetadataMapper = void 0;
+const shared_utils_1 = require("@nestjs/common/utils/shared.utils");
+const lodash_1 = require("lodash");
+const constants_1 = require("../constants");
+const is_body_parameter_util_1 = require("../utils/is-body-parameter.util");
+class ParametersMetadataMapper {
+    constructor(modelPropertiesAccessor) {
+        this.modelPropertiesAccessor = modelPropertiesAccessor;
+    }
+    transformModelToProperties(parameters) {
+        const properties = (0, lodash_1.flatMap)(parameters, (param) => {
+            if (!param || param.type === Object || !param.type) {
+                return undefined;
+            }
+            if (param.name) {
+                return param;
+            }
+            if ((0, is_body_parameter_util_1.isBodyParameter)(param)) {
+                const isCtor = param.type && (0, shared_utils_1.isFunction)(param.type);
+                const name = isCtor ? param.type.name : param.type;
+                return Object.assign(Object.assign({}, param), { name });
+            }
+            const { prototype } = param.type;
+            this.modelPropertiesAccessor.applyMetadataFactory(prototype);
+            const modelProperties = this.modelPropertiesAccessor.getModelProperties(prototype);
+            return modelProperties.map((key) => this.mergeImplicitWithExplicit(key, prototype, param));
+        });
+        return properties.filter(lodash_1.identity);
+    }
+    mergeImplicitWithExplicit(key, prototype, param) {
+        const reflectedParam = Reflect.getMetadata(constants_1.DECORATORS.API_MODEL_PROPERTIES, prototype, key) ||
+            {};
+        return Object.assign(Object.assign(Object.assign({}, param), reflectedParam), { name: reflectedParam.name || key });
+    }
+}
+exports.ParametersMetadataMapper = ParametersMetadataMapper;

package/dist/services/response-object-factory.d.ts

@@ -0,0 +1,28 @@
+import { ApiResponseMetadata, ApiResponseSchemaHost } from '../decorators';
+import { SchemaObject } from '../interfaces/open-api-spec.interface';
+export type FactoriesNeededByResponseFactory = {
+    linkName: (controllerKey: string, methodKey: string, fieldKey: string) => string;
+    operationId: (controllerKey: string, methodKey: string) => string;
+};
+export declare class ResponseObjectFactory {
+    private readonly mimetypeContentWrapper;
+    private readonly modelPropertiesAccessor;
+    private readonly swaggerTypesMapper;
+    private readonly schemaObjectFactory;
+    private readonly responseObjectMapper;
+    create(response: ApiResponseMetadata, produces: string[], schemas: Record<string, SchemaObject>, factories: FactoriesNeededByResponseFactory): (ApiResponseSchemaHost & import("../decorators").ApiResponseCommonMetadata & {
+        example?: any;
+    }) | (ApiResponseSchemaHost & import("../decorators").ApiResponseCommonMetadata & {
+        examples?: {
+            [key: string]: import("../decorators").ApiResponseExamples;
+        };
+    }) | {
+        content: import("../interfaces/open-api-spec.interface").ContentObject;
+    } | {
+        content: {
+            [x: string]: {
+                [x: string]: any;
+            };
+        };
+    };
+}

package/dist/services/response-object-factory.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseObjectFactory = void 0;
+const lodash_1 = require("lodash");
+const constants_1 = require("../constants");
+const is_built_in_type_util_1 = require("../utils/is-built-in-type.util");
+const remove_undefined_keys_1 = require("../utils/remove-undefined-keys");
+const mimetype_content_wrapper_1 = require("./mimetype-content-wrapper");
+const model_properties_accessor_1 = require("./model-properties-accessor");
+const response_object_mapper_1 = require("./response-object-mapper");
+const schema_object_factory_1 = require("./schema-object-factory");
+const swagger_types_mapper_1 = require("./swagger-types-mapper");
+class ResponseObjectFactory {
+    constructor() {
+        this.mimetypeContentWrapper = new mimetype_content_wrapper_1.MimetypeContentWrapper();
+        this.modelPropertiesAccessor = new model_properties_accessor_1.ModelPropertiesAccessor();
+        this.swaggerTypesMapper = new swagger_types_mapper_1.SwaggerTypesMapper();
+        this.schemaObjectFactory = new schema_object_factory_1.SchemaObjectFactory(this.modelPropertiesAccessor, this.swaggerTypesMapper);
+        this.responseObjectMapper = new response_object_mapper_1.ResponseObjectMapper();
+    }
+    create(response, produces, schemas, factories) {
+        var _a;
+        const { type, isArray } = response;
+        response = (0, lodash_1.omit)(response, ['isArray']);
+        const isStreaming = response.isStreaming;
+        const streamingContentType = response.contentType;
+        if (isStreaming) {
+            const exampleKeys = ['example', 'examples'];
+            const contentType = streamingContentType || (produces === null || produces === void 0 ? void 0 : produces[0]);
+            let itemSchema;
+            if (type) {
+                if ((0, is_built_in_type_util_1.isBuiltInType)(type) || typeof type === 'string') {
+                    const typeName = type && (0, lodash_1.isFunction)(type)
+                        ? type.name
+                        : type;
+                    const swaggerType = this.swaggerTypesMapper.mapTypeToOpenAPIType(typeName);
+                    itemSchema = { type: swaggerType };
+                }
+                else {
+                    const name = this.schemaObjectFactory.exploreModelSchema(type, schemas);
+                    itemSchema = { $ref: `#/components/schemas/${name}` };
+                }
+            }
+            const mediaTypeObject = (0, remove_undefined_keys_1.removeUndefinedKeys)(Object.assign({ itemSchema }, (0, lodash_1.pick)(response, exampleKeys)));
+            const keysToOmit = [...exampleKeys, 'type', 'isStreaming', 'contentType'];
+            return Object.assign(Object.assign({}, (0, lodash_1.omit)(response, keysToOmit)), (contentType
+                ? { content: { [contentType]: mediaTypeObject } }
+                : undefined));
+        }
+        if (!type) {
+            return this.responseObjectMapper.wrapSchemaWithContent(response, produces);
+        }
+        if ((0, is_built_in_type_util_1.isBuiltInType)(type)) {
+            const typeName = type && (0, lodash_1.isFunction)(type) ? type.name : type;
+            const swaggerType = this.swaggerTypesMapper.mapTypeToOpenAPIType(typeName);
+            const exampleKeys = ['example', 'examples'];
+            if (isArray) {
+                const content = this.mimetypeContentWrapper.wrap(produces, {
+                    schema: {
+                        type: 'array',
+                        items: {
+                            type: swaggerType
+                        }
+                    }
+                });
+                return Object.assign(Object.assign({}, (0, lodash_1.omit)(response, exampleKeys)), content);
+            }
+            const content = this.mimetypeContentWrapper.wrap(produces, {
+                schema: {
+                    type: swaggerType
+                }
+            });
+            return Object.assign(Object.assign({}, (0, lodash_1.omit)(response, exampleKeys)), content);
+        }
+        const name = this.schemaObjectFactory.exploreModelSchema(type, schemas);
+        if ((0, lodash_1.isFunction)(type) && type.prototype) {
+            const { prototype } = type;
+            const links = {};
+            const properties = this.modelPropertiesAccessor.getModelProperties(prototype);
+            const generateLink = (controllerPrototype, method, parameter, field) => {
+                if (!factories) {
+                    return;
+                }
+                const linkName = factories.linkName(controllerPrototype.constructor.name, method.name, field);
+                links[linkName] = {
+                    operationId: factories.operationId(controllerPrototype.constructor.name, method.name),
+                    parameters: {
+                        [parameter]: `$response.body#/${field}`
+                    }
+                };
+            };
+            for (const key of properties) {
+                const metadata = (_a = Reflect.getMetadata(constants_1.DECORATORS.API_MODEL_PROPERTIES, prototype, key)) !== null && _a !== void 0 ? _a : {};
+                if (!metadata.link) {
+                    continue;
+                }
+                const linkedType = metadata.link();
+                const linkedGetterInfo = Reflect.getMetadata(constants_1.DECORATORS.API_DEFAULT_GETTER, linkedType.prototype);
+                if (!linkedGetterInfo) {
+                    continue;
+                }
+                const { getter, parameter, prototype: controllerPrototype } = linkedGetterInfo;
+                generateLink(controllerPrototype, getter, parameter, key);
+            }
+            const customLinks = Reflect.getMetadata(constants_1.DECORATORS.API_LINK, prototype);
+            for (const customLink of customLinks !== null && customLinks !== void 0 ? customLinks : []) {
+                const { method, parameter, field, prototype: controllerPrototype } = customLink;
+                generateLink(controllerPrototype, method, parameter, field);
+            }
+            if (!(0, lodash_1.isEmpty)(links)) {
+                response.links = Object.assign(links, response.links);
+            }
+        }
+        if (isArray) {
+            return this.responseObjectMapper.toArrayRefObject(response, name, produces);
+        }
+        return this.responseObjectMapper.toRefObject(response, name, produces);
+    }
+}
+exports.ResponseObjectFactory = ResponseObjectFactory;

package/dist/services/response-object-mapper.d.ts

@@ -0,0 +1,39 @@
+import { ApiResponseMetadata, ApiResponseSchemaHost } from '../decorators';
+export declare class ResponseObjectMapper {
+    private readonly mimetypeContentWrapper;
+    toArrayRefObject(response: Record<string, any>, name: string, produces: string[]): {
+        content: import("../interfaces/open-api-spec.interface").ContentObject;
+    };
+    toRefObject(response: Record<string, any>, name: string, produces: string[]): {
+        content: import("../interfaces/open-api-spec.interface").ContentObject;
+    };
+    wrapSchemaWithContent(response: ApiResponseSchemaHost & ApiResponseMetadata, produces: string[]): (ApiResponseSchemaHost & import("../decorators").ApiResponseCommonMetadata & {
+        example?: any;
+    }) | (ApiResponseSchemaHost & import("../decorators").ApiResponseCommonMetadata & {
+        examples?: {
+            [key: string]: import("../decorators").ApiResponseExamples;
+        };
+    }) | {
+        content: import("../interfaces/open-api-spec.interface").ContentObject;
+        schema?: import("../interfaces/open-api-spec.interface").SchemaObject & Partial<import("../interfaces/open-api-spec.interface").ReferenceObject>;
+        status?: number | "default" | "1XX" | "2XX" | "3XX" | "4XX" | "5XX";
+        description?: string;
+        headers?: import("../interfaces/open-api-spec.interface").HeadersObject;
+        links?: import("../interfaces/open-api-spec.interface").LinksObject;
+        type?: import("@nestjs/common").Type<unknown> | Function | [Function] | string;
+        isArray?: boolean;
+        example?: any;
+    } | {
+        content: import("../interfaces/open-api-spec.interface").ContentObject;
+        schema?: import("../interfaces/open-api-spec.interface").SchemaObject & Partial<import("../interfaces/open-api-spec.interface").ReferenceObject>;
+        status?: number | "default" | "1XX" | "2XX" | "3XX" | "4XX" | "5XX";
+        description?: string;
+        headers?: import("../interfaces/open-api-spec.interface").HeadersObject;
+        links?: import("../interfaces/open-api-spec.interface").LinksObject;
+        type?: import("@nestjs/common").Type<unknown> | Function | [Function] | string;
+        isArray?: boolean;
+        examples?: {
+            [key: string]: import("../decorators").ApiResponseExamples;
+        };
+    };
+}

package/dist/services/response-object-mapper.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseObjectMapper = void 0;
+const lodash_1 = require("lodash");
+const utils_1 = require("../utils");
+const mimetype_content_wrapper_1 = require("./mimetype-content-wrapper");
+class ResponseObjectMapper {
+    constructor() {
+        this.mimetypeContentWrapper = new mimetype_content_wrapper_1.MimetypeContentWrapper();
+    }
+    toArrayRefObject(response, name, produces) {
+        const exampleKeys = ['example', 'examples'];
+        return Object.assign(Object.assign({}, (0, lodash_1.omit)(response, exampleKeys)), this.mimetypeContentWrapper.wrap(produces, Object.assign({ schema: {
+                type: 'array',
+                items: {
+                    $ref: (0, utils_1.getSchemaPath)(name)
+                }
+            } }, (0, lodash_1.pick)(response, exampleKeys))));
+    }
+    toRefObject(response, name, produces) {
+        const exampleKeys = ['example', 'examples'];
+        return Object.assign(Object.assign({}, (0, lodash_1.omit)(response, exampleKeys)), this.mimetypeContentWrapper.wrap(produces, Object.assign({ schema: {
+                $ref: (0, utils_1.getSchemaPath)(name)
+            } }, (0, lodash_1.pick)(response, exampleKeys))));
+    }
+    wrapSchemaWithContent(response, produces) {
+        if (!response.schema &&
+            !('example' in response) &&
+            !('examples' in response)) {
+            return response;
+        }
+        const exampleKeys = ['example', 'examples'];
+        const content = this.mimetypeContentWrapper.wrap(produces, Object.assign({ schema: response.schema }, (0, lodash_1.pick)(response, exampleKeys)));
+        const keysToOmit = [...exampleKeys, 'schema'];
+        return Object.assign(Object.assign({}, (0, lodash_1.omit)(response, keysToOmit)), content);
+    }
+}
+exports.ResponseObjectMapper = ResponseObjectMapper;