nestjs-openapi-next 1.0.0

package/dist/services/swagger-types-mapper.d.ts

@@ -0,0 +1,260 @@
+import { ApiPropertyOptions } from '../decorators';
+import { BaseParameterObject, ReferenceObject, SchemaObject } from '../interfaces/open-api-spec.interface';
+import { ParamWithTypeMetadata } from './parameter-metadata-accessor';
+type KeysToRemove = keyof ApiPropertyOptions | '$ref' | 'properties' | 'enumName' | 'enumSchema' | 'selfRequired';
+export declare class SwaggerTypesMapper {
+    private readonly keysToRemove;
+    mapParamTypes(parameters: Array<ParamWithTypeMetadata | BaseParameterObject>): (Partial<BaseParameterObject> | Partial<ParamWithTypeMetadata> | {
+        schema: {
+            type: string;
+            items: any;
+            nullable?: boolean;
+            discriminator?: import("../interfaces/open-api-spec.interface").DiscriminatorObject;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            xml?: import("../interfaces/open-api-spec.interface").XmlObject;
+            externalDocs?: import("../interfaces/open-api-spec.interface").ExternalDocumentationObject;
+            example?: any;
+            examples?: any[] | Record<string, any>;
+            deprecated?: boolean;
+            allOf?: (SchemaObject | ReferenceObject)[];
+            oneOf?: (SchemaObject | ReferenceObject)[];
+            anyOf?: (SchemaObject | ReferenceObject)[];
+            not?: SchemaObject | ReferenceObject;
+            properties?: Record<string, SchemaObject | ReferenceObject>;
+            additionalProperties?: SchemaObject | ReferenceObject | boolean;
+            patternProperties?: Record<string, SchemaObject | ReferenceObject> | undefined;
+            description?: string;
+            format?: string;
+            default?: any;
+            title?: string;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: boolean;
+            minimum?: number;
+            exclusiveMinimum?: boolean;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string[];
+            enum?: any[];
+            'x-enumNames'?: string[];
+        };
+    } | {
+        schema: import("lodash").Dictionary<any>;
+        description?: string;
+        required?: boolean;
+        deprecated?: boolean;
+        allowEmptyValue?: boolean;
+        style?: import("../interfaces/open-api-spec.interface").ParameterStyle;
+        explode?: boolean;
+        allowReserved?: boolean;
+        examples?: Record<string, import("../interfaces/open-api-spec.interface").ExampleObject | ReferenceObject>;
+        example?: any;
+        content?: import("../interfaces/open-api-spec.interface").ContentObject;
+    } | {
+        schema: import("lodash").Dictionary<any>;
+        name?: string | number | object;
+        type?: import("@nestjs/common").Type<unknown>;
+        in?: import("../interfaces/open-api-spec.interface").ParameterLocation | "body" | "placeholder";
+        isArray?: boolean;
+        items?: SchemaObject;
+        required?: boolean;
+        enum?: unknown[];
+        enumName?: string;
+        enumSchema?: import("../interfaces/enum-schema-attributes.interface").EnumSchemaAttributes;
+        selfRequired?: boolean;
+    })[];
+    mapTypeToOpenAPIType(type: string | Function): string;
+    mapEnumArrayType(param: Record<string, any>, keysToRemove: KeysToRemove[]): {
+        schema: {
+            type: string;
+            items: any;
+            nullable?: boolean;
+            discriminator?: import("../interfaces/open-api-spec.interface").DiscriminatorObject;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            xml?: import("../interfaces/open-api-spec.interface").XmlObject;
+            externalDocs?: import("../interfaces/open-api-spec.interface").ExternalDocumentationObject;
+            example?: any;
+            examples?: any[] | Record<string, any>;
+            deprecated?: boolean;
+            allOf?: (SchemaObject | ReferenceObject)[];
+            oneOf?: (SchemaObject | ReferenceObject)[];
+            anyOf?: (SchemaObject | ReferenceObject)[];
+            not?: SchemaObject | ReferenceObject;
+            properties?: Record<string, SchemaObject | ReferenceObject>;
+            additionalProperties?: SchemaObject | ReferenceObject | boolean;
+            patternProperties?: Record<string, SchemaObject | ReferenceObject> | undefined;
+            description?: string;
+            format?: string;
+            default?: any;
+            title?: string;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: boolean;
+            minimum?: number;
+            exclusiveMinimum?: boolean;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string[];
+            enum?: any[];
+            'x-enumNames'?: string[];
+        };
+    };
+    mapArrayType(param: (ParamWithTypeMetadata & SchemaObject) | BaseParameterObject, keysToRemove: KeysToRemove[]): {
+        schema: {
+            type: string;
+            items: any;
+            nullable?: boolean;
+            discriminator?: import("../interfaces/open-api-spec.interface").DiscriminatorObject;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            xml?: import("../interfaces/open-api-spec.interface").XmlObject;
+            externalDocs?: import("../interfaces/open-api-spec.interface").ExternalDocumentationObject;
+            example?: any;
+            examples?: any[] | Record<string, any>;
+            deprecated?: boolean;
+            allOf?: (SchemaObject | ReferenceObject)[];
+            oneOf?: (SchemaObject | ReferenceObject)[];
+            anyOf?: (SchemaObject | ReferenceObject)[];
+            not?: SchemaObject | ReferenceObject;
+            properties?: Record<string, SchemaObject | ReferenceObject>;
+            additionalProperties?: SchemaObject | ReferenceObject | boolean;
+            patternProperties?: Record<string, SchemaObject | ReferenceObject> | undefined;
+            description?: string;
+            format?: string;
+            default?: any;
+            title?: string;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: boolean;
+            minimum?: number;
+            exclusiveMinimum?: boolean;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string[];
+            enum?: any[];
+            'x-enumNames'?: string[];
+        };
+        description?: string;
+        required?: boolean;
+        deprecated?: boolean;
+        allowEmptyValue?: boolean;
+        style?: import("../interfaces/open-api-spec.interface").ParameterStyle;
+        explode?: boolean;
+        allowReserved?: boolean;
+        examples?: Record<string, import("../interfaces/open-api-spec.interface").ExampleObject | ReferenceObject>;
+        example?: any;
+        content?: import("../interfaces/open-api-spec.interface").ContentObject;
+    } | {
+        schema: {
+            type: string;
+            items: any;
+            nullable?: boolean;
+            discriminator?: import("../interfaces/open-api-spec.interface").DiscriminatorObject;
+            readOnly?: boolean;
+            writeOnly?: boolean;
+            xml?: import("../interfaces/open-api-spec.interface").XmlObject;
+            externalDocs?: import("../interfaces/open-api-spec.interface").ExternalDocumentationObject;
+            example?: any;
+            examples?: any[] | Record<string, any>;
+            deprecated?: boolean;
+            allOf?: (SchemaObject | ReferenceObject)[];
+            oneOf?: (SchemaObject | ReferenceObject)[];
+            anyOf?: (SchemaObject | ReferenceObject)[];
+            not?: SchemaObject | ReferenceObject;
+            properties?: Record<string, SchemaObject | ReferenceObject>;
+            additionalProperties?: SchemaObject | ReferenceObject | boolean;
+            patternProperties?: Record<string, SchemaObject | ReferenceObject> | undefined;
+            description?: string;
+            format?: string;
+            default?: any;
+            title?: string;
+            multipleOf?: number;
+            maximum?: number;
+            exclusiveMaximum?: boolean;
+            minimum?: number;
+            exclusiveMinimum?: boolean;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string;
+            maxItems?: number;
+            minItems?: number;
+            uniqueItems?: boolean;
+            maxProperties?: number;
+            minProperties?: number;
+            required?: string[];
+            enum?: any[];
+            'x-enumNames'?: string[];
+        };
+        name?: string | number | object;
+        type?: import("@nestjs/common").Type<unknown> & string;
+        in?: import("../interfaces/open-api-spec.interface").ParameterLocation | "body" | "placeholder";
+        isArray?: boolean;
+        items?: SchemaObject | (SchemaObject & ReferenceObject);
+        required?: boolean & string[];
+        enum?: unknown[] & any[];
+        enumName?: string;
+        enumSchema?: import("../interfaces/enum-schema-attributes.interface").EnumSchemaAttributes;
+        selfRequired?: boolean;
+        nullable?: boolean;
+        discriminator?: import("../interfaces/open-api-spec.interface").DiscriminatorObject;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        xml?: import("../interfaces/open-api-spec.interface").XmlObject;
+        externalDocs?: import("../interfaces/open-api-spec.interface").ExternalDocumentationObject;
+        example?: any;
+        examples?: any[] | Record<string, any>;
+        deprecated?: boolean;
+        allOf?: (SchemaObject | ReferenceObject)[];
+        oneOf?: (SchemaObject | ReferenceObject)[];
+        anyOf?: (SchemaObject | ReferenceObject)[];
+        not?: SchemaObject | ReferenceObject;
+        properties?: Record<string, SchemaObject | ReferenceObject>;
+        additionalProperties?: SchemaObject | ReferenceObject | boolean;
+        patternProperties?: Record<string, SchemaObject | ReferenceObject> | undefined;
+        description?: string;
+        format?: string;
+        default?: any;
+        title?: string;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: boolean;
+        minimum?: number;
+        exclusiveMinimum?: boolean;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        'x-enumNames'?: string[];
+    };
+    getSchemaOptionsKeys(): Array<keyof SchemaObject>;
+    private getSchemaOptions;
+    private isEnumArrayType;
+    private hasSchemaDefinition;
+    private hasRawContentDefinition;
+    private omitParamKeys;
+}
+export {};

package/dist/services/swagger-types-mapper.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwaggerTypesMapper = void 0;
+const lodash_1 = require("lodash");
+class SwaggerTypesMapper {
+    constructor() {
+        this.keysToRemove = [
+            'isArray',
+            'enum',
+            'enumName',
+            'enumSchema',
+            '$ref',
+            'selfRequired',
+            ...this.getSchemaOptionsKeys()
+        ];
+    }
+    mapParamTypes(parameters) {
+        return parameters.map((param) => {
+            if (this.hasSchemaDefinition(param) ||
+                this.hasRawContentDefinition(param)) {
+                if (Array.isArray(param.required) && 'schema' in param) {
+                    param.schema.required = param.required;
+                    delete param.required;
+                }
+                if ('selfRequired' in param) {
+                    param.required = param.selfRequired;
+                }
+                return this.omitParamKeys(param);
+            }
+            const { type } = param;
+            const typeName = type && (0, lodash_1.isFunction)(type)
+                ? this.mapTypeToOpenAPIType(type.name)
+                : this.mapTypeToOpenAPIType(type);
+            const paramWithTypeMetadata = (0, lodash_1.omitBy)(Object.assign(Object.assign({}, param), { type: typeName }), lodash_1.isUndefined);
+            if (this.isEnumArrayType(paramWithTypeMetadata)) {
+                return this.mapEnumArrayType(paramWithTypeMetadata, this.keysToRemove);
+            }
+            else if (paramWithTypeMetadata.isArray) {
+                return this.mapArrayType(paramWithTypeMetadata, this.keysToRemove);
+            }
+            return Object.assign(Object.assign({}, (0, lodash_1.omit)(param, this.keysToRemove)), { schema: (0, lodash_1.omitBy)(Object.assign(Object.assign(Object.assign({}, this.getSchemaOptions(param)), (param.schema || {})), { enum: paramWithTypeMetadata.enum, type: paramWithTypeMetadata.type, $ref: paramWithTypeMetadata.$ref }), lodash_1.isUndefined) });
+        });
+    }
+    mapTypeToOpenAPIType(type) {
+        if (!(type && type.charAt)) {
+            return;
+        }
+        return type.charAt(0).toLowerCase() + type.slice(1);
+    }
+    mapEnumArrayType(param, keysToRemove) {
+        return Object.assign(Object.assign({}, (0, lodash_1.omit)(param, keysToRemove)), { schema: Object.assign(Object.assign({}, this.getSchemaOptions(param)), { type: 'array', items: param.items }) });
+    }
+    mapArrayType(param, keysToRemove) {
+        const itemsModifierKeys = ['format', 'maximum', 'minimum', 'pattern'];
+        const items = param.items ||
+            (0, lodash_1.omitBy)(Object.assign(Object.assign({}, (param.schema || {})), { enum: param.enum, type: this.mapTypeToOpenAPIType(param.type) }), lodash_1.isUndefined);
+        const modifierProperties = (0, lodash_1.pick)(param, itemsModifierKeys);
+        return Object.assign(Object.assign({}, (0, lodash_1.omit)(param, keysToRemove)), { schema: Object.assign(Object.assign({}, (0, lodash_1.omit)(this.getSchemaOptions(param), [...itemsModifierKeys])), { type: 'array', items: (0, lodash_1.isString)(items.type)
+                    ? Object.assign({ type: items.type }, modifierProperties) : Object.assign(Object.assign({}, items.type), modifierProperties) }) });
+    }
+    getSchemaOptionsKeys() {
+        return [
+            'properties',
+            'patternProperties',
+            'additionalProperties',
+            'minimum',
+            'maximum',
+            'maxProperties',
+            'minItems',
+            'minProperties',
+            'maxItems',
+            'minLength',
+            'maxLength',
+            'exclusiveMaximum',
+            'exclusiveMinimum',
+            'uniqueItems',
+            'title',
+            'format',
+            'pattern',
+            'nullable',
+            'default',
+            'example',
+            'oneOf',
+            'anyOf',
+            'type',
+            'items'
+        ];
+    }
+    getSchemaOptions(param) {
+        const schemaKeys = this.getSchemaOptionsKeys();
+        const optionsObject = schemaKeys.reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [key]: param[key] })), {});
+        return (0, lodash_1.omitBy)(optionsObject, lodash_1.isUndefined);
+    }
+    isEnumArrayType(param) {
+        return param.isArray && param.items && param.items.enum;
+    }
+    hasSchemaDefinition(param) {
+        return !!param.schema;
+    }
+    hasRawContentDefinition(param) {
+        return 'content' in param;
+    }
+    omitParamKeys(param) {
+        return (0, lodash_1.omit)(param, this.keysToRemove);
+    }
+}
+exports.SwaggerTypesMapper = SwaggerTypesMapper;

package/dist/storages/global-parameters.storage.d.ts

@@ -0,0 +1,8 @@
+import { ParameterObject } from '../interfaces/open-api-spec.interface';
+export declare class GlobalParametersStorageHost {
+    private parameters;
+    add(...parameters: ParameterObject[]): void;
+    getAll(): ParameterObject[];
+    clear(): void;
+}
+export declare const GlobalParametersStorage: GlobalParametersStorageHost;

package/dist/storages/global-parameters.storage.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalParametersStorage = exports.GlobalParametersStorageHost = void 0;
+class GlobalParametersStorageHost {
+    constructor() {
+        this.parameters = new Array();
+    }
+    add(...parameters) {
+        this.parameters.push(...parameters);
+    }
+    getAll() {
+        return this.parameters;
+    }
+    clear() {
+        this.parameters = [];
+    }
+}
+exports.GlobalParametersStorageHost = GlobalParametersStorageHost;
+const globalRef = global;
+exports.GlobalParametersStorage = globalRef.SwaggerGlobalParametersStorage ||
+    (globalRef.SwaggerGlobalParametersStorage =
+        new GlobalParametersStorageHost());

package/dist/storages/global-responses.storage.d.ts

@@ -0,0 +1,10 @@
+import { ApiResponseOptions } from '../decorators';
+type GlobalResponesMap = Record<string, Omit<ApiResponseOptions, 'status'>>;
+export declare class GlobalResponsesStorageHost {
+    private responses;
+    add(responses: GlobalResponesMap): void;
+    getAll(): GlobalResponesMap;
+    clear(): void;
+}
+export declare const GlobalResponsesStorage: GlobalResponsesStorageHost;
+export {};

package/dist/storages/global-responses.storage.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalResponsesStorage = exports.GlobalResponsesStorageHost = void 0;
+class GlobalResponsesStorageHost {
+    constructor() {
+        this.responses = {};
+    }
+    add(responses) {
+        this.responses = Object.assign(Object.assign({}, this.responses), responses);
+    }
+    getAll() {
+        return this.responses;
+    }
+    clear() {
+        this.responses = {};
+    }
+}
+exports.GlobalResponsesStorageHost = GlobalResponsesStorageHost;
+const globalRef = global;
+exports.GlobalResponsesStorage = globalRef.SwaggerGlobalResponsesStorage ||
+    (globalRef.SwaggerGlobalResponsesStorage = new GlobalResponsesStorageHost());

package/dist/swagger-explorer.d.ts

@@ -0,0 +1,41 @@
+import { Controller } from '@nestjs/common/interfaces';
+import { ApplicationConfig } from '@nestjs/core';
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { OperationIdFactory } from './interfaces';
+import { DenormalizedDoc } from './interfaces/denormalized-doc.interface';
+import { SchemaObject } from './interfaces/open-api-spec.interface';
+import { SchemaObjectFactory } from './services/schema-object-factory';
+export declare class SwaggerExplorer {
+    private readonly schemaObjectFactory;
+    private readonly options;
+    private readonly mimetypeContentWrapper;
+    private readonly metadataScanner;
+    private readonly schemas;
+    private operationIdFactory;
+    private routePathFactory?;
+    private linkNameFactory;
+    constructor(schemaObjectFactory: SchemaObjectFactory, options?: {
+        httpAdapterType?: string;
+    });
+    exploreController(wrapper: InstanceWrapper<Controller>, applicationConfig: ApplicationConfig, options: {
+        modulePath?: string;
+        globalPrefix?: string;
+        operationIdFactory?: OperationIdFactory;
+        linkNameFactory?: (controllerKey: string, methodKey: string, fieldKey: string) => string;
+        autoTagControllers?: boolean;
+    }): DenormalizedDoc[];
+    getSchemas(): Record<string, SchemaObject>;
+    private generateDenormalizedDocument;
+    private exploreGlobalMetadata;
+    private exploreRoutePathAndMethod;
+    private getOperationId;
+    private getRoutePathVersions;
+    private reflectControllerPath;
+    private validateRoutePath;
+    private mergeMetadata;
+    private deepMergeMetadata;
+    private mergeValues;
+    private migrateOperationSchema;
+    private registerExtraModels;
+    private getVersionMetadata;
+}