vona-module-a-swagger 5.0.2

package/dist/lib/services/schema-object-factory.d.ts

@@ -0,0 +1,160 @@
+import { Type } from 'vona';
+import { BaseParameterObject, ParameterObject, ReferenceObject, SchemaObject } from '../interfaces/open-api-spec.interface.js';
+import { SchemaObjectMetadata } from '../interfaces/schema-object-metadata.interface.js';
+import { ModelPropertiesAccessor } from './model-properties-accessor.js';
+import { ParamWithTypeMetadata } from './parameter-metadata-accessor.js';
+import { SwaggerTypesMapper } from './swagger-types-mapper.js';
+export declare class SchemaObjectFactory {
+    private readonly modelPropertiesAccessor;
+    private readonly swaggerTypesMapper;
+    constructor(modelPropertiesAccessor: ModelPropertiesAccessor, swaggerTypesMapper: SwaggerTypesMapper);
+    createFromModel(parameters: ParamWithTypeMetadata[], schemas: Record<string, SchemaObject>): Array<ParamWithTypeMetadata | BaseParameterObject>;
+    getCustomType(param: ParamWithTypeMetadata, schemas: Record<string, SchemaObject>): {
+        name: string | number | object;
+        schema: {
+            type: string;
+            items: {
+                $ref: string;
+                nullable?: boolean | undefined;
+                discriminator?: import("../interfaces/open-api-spec.interface.js").DiscriminatorObject | undefined;
+                readOnly?: boolean | undefined;
+                writeOnly?: boolean | undefined;
+                xml?: import("../interfaces/open-api-spec.interface.js").XmlObject | undefined;
+                externalDocs?: import("../interfaces/open-api-spec.interface.js").ExternalDocumentationObject | undefined;
+                example?: any;
+                examples?: any[] | Record<string, any> | undefined;
+                deprecated?: boolean | undefined;
+                type?: string | undefined;
+                allOf?: (SchemaObject | ReferenceObject)[] | undefined;
+                oneOf?: (SchemaObject | ReferenceObject)[] | undefined;
+                anyOf?: (SchemaObject | ReferenceObject)[] | undefined;
+                not?: SchemaObject | ReferenceObject | undefined;
+                items?: SchemaObject | ReferenceObject | undefined;
+                properties?: Record<string, SchemaObject | ReferenceObject> | undefined;
+                additionalProperties?: boolean | SchemaObject | ReferenceObject | undefined;
+                patternProperties?: any;
+                description?: string | undefined;
+                format?: string | undefined;
+                default?: any;
+                title?: string | undefined;
+                multipleOf?: number | undefined;
+                maximum?: number | undefined;
+                exclusiveMaximum?: boolean | undefined;
+                minimum?: number | undefined;
+                exclusiveMinimum?: boolean | undefined;
+                maxLength?: number | undefined;
+                minLength?: number | undefined;
+                pattern?: string | undefined;
+                maxItems?: number | undefined;
+                minItems?: number | undefined;
+                uniqueItems?: boolean | undefined;
+                maxProperties?: number | undefined;
+                minProperties?: number | undefined;
+                required?: string[] | undefined;
+                enum?: any[] | undefined;
+            } | {
+                $ref: string;
+            };
+        };
+        type?: Type<unknown> | undefined;
+        in?: import("../interfaces/open-api-spec.interface.js").ParameterLocation | "body" | "placeholder" | undefined;
+        isArray?: boolean | undefined;
+        items?: SchemaObject | undefined;
+        required: true;
+        enum?: unknown[] | undefined;
+        enumName?: string | undefined;
+        enumSchema?: import("../interfaces/enum-schema-attributes.interface.js").EnumSchemaAttributes | undefined;
+    } | {
+        name: string | number | object;
+        schema: {
+            $ref: string;
+            nullable?: boolean | undefined;
+            discriminator?: import("../interfaces/open-api-spec.interface.js").DiscriminatorObject | undefined;
+            readOnly?: boolean | undefined;
+            writeOnly?: boolean | undefined;
+            xml?: import("../interfaces/open-api-spec.interface.js").XmlObject | undefined;
+            externalDocs?: import("../interfaces/open-api-spec.interface.js").ExternalDocumentationObject | undefined;
+            example?: any;
+            examples?: any[] | Record<string, any> | undefined;
+            deprecated?: boolean | undefined;
+            type?: string | undefined;
+            allOf?: (SchemaObject | ReferenceObject)[] | undefined;
+            oneOf?: (SchemaObject | ReferenceObject)[] | undefined;
+            anyOf?: (SchemaObject | ReferenceObject)[] | undefined;
+            not?: SchemaObject | ReferenceObject | undefined;
+            items?: SchemaObject | ReferenceObject | undefined;
+            properties?: Record<string, SchemaObject | ReferenceObject> | undefined;
+            additionalProperties?: boolean | SchemaObject | ReferenceObject | undefined;
+            patternProperties?: any;
+            description?: string | undefined;
+            format?: string | undefined;
+            default?: any;
+            title?: string | undefined;
+            multipleOf?: number | undefined;
+            maximum?: number | undefined;
+            exclusiveMaximum?: boolean | undefined;
+            minimum?: number | undefined;
+            exclusiveMinimum?: boolean | undefined;
+            maxLength?: number | undefined;
+            minLength?: number | undefined;
+            pattern?: string | undefined;
+            maxItems?: number | undefined;
+            minItems?: number | undefined;
+            uniqueItems?: boolean | undefined;
+            maxProperties?: number | undefined;
+            minProperties?: number | undefined;
+            required?: string[] | undefined;
+            enum?: any[] | undefined;
+        } | {
+            $ref: string;
+        };
+        type?: Type<unknown> | undefined;
+        in?: import("../interfaces/open-api-spec.interface.js").ParameterLocation | "body" | "placeholder" | undefined;
+        isArray?: boolean | undefined;
+        items?: SchemaObject | undefined;
+        required: true;
+        enum?: unknown[] | undefined;
+        enumName?: string | undefined;
+        enumSchema?: import("../interfaces/enum-schema-attributes.interface.js").EnumSchemaAttributes | undefined;
+    };
+    private createQueryOrParamSchema;
+    /**
+     *
+     * @param type
+     * @param schemas
+     * @param pendingSchemasRefs Used internally to avoid infinite recursion
+     */
+    extractPropertiesFromType(type: Type<unknown>, schemas: Record<string, SchemaObject>, pendingSchemasRefs?: string[]): ParameterObject[] | undefined;
+    /**
+     *
+     * @param type
+     * @param schemas
+     * @param pendingSchemasRefs Used internally to avoid infinite recursion
+     */
+    exploreModelSchema(type: Type<unknown> | Function | undefined, schemas: Record<string, SchemaObject>, pendingSchemasRefs?: string[]): string;
+    getSchemaName(type?: Function | Type<unknown>): any;
+    mergePropertyWithMetadata(key: string, prototype: Type<unknown>, schemas: Record<string, SchemaObject>, pendingSchemaRefs: string[], metadata?: SchemaObjectMetadata): SchemaObjectMetadata | ReferenceObject | ParameterObject | (SchemaObject & {
+        selfRequired?: boolean;
+    });
+    createEnumParam(param: ParamWithTypeMetadata & BaseParameterObject, schemas: Record<string, SchemaObject>): any;
+    createEnumSchemaType(key: string, metadata: SchemaObjectMetadata, schemas: Record<string, SchemaObject>): SchemaObjectMetadata;
+    createNotBuiltInTypeReference(key: string, metadata: SchemaObjectMetadata, trueMetadataType: unknown, schemas: Record<string, SchemaObject>, pendingSchemaRefs: string[]): SchemaObjectMetadata;
+    transformToArraySchemaProperty(metadata: SchemaObjectMetadata, key: string, type?: string | Record<string, any>): SchemaObjectMetadata;
+    mapArrayCtorParam(param: ParamWithTypeMetadata): any;
+    createFromObjectLiteral(key: string, literalObj: Record<string, any>, schemas: Record<string, SchemaObject>): {
+        name: string;
+        type: string;
+        properties: {};
+        required: any[];
+    };
+    createFromNestedArray(key: string, metadata: SchemaObjectMetadata, schemas: Record<string, SchemaObject>, pendingSchemaRefs: string[]): any;
+    private createSchemaMetadata;
+    private isArrayCtor;
+    private isPrimitiveType;
+    private isLazyTypeFunc;
+    private getTypeName;
+    private isObjectLiteral;
+    private isBigInt;
+    private extractPropertyModifiers;
+}
+//# sourceMappingURL=schema-object-factory.d.ts.map

package/dist/lib/services/schema-object-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-object-factory.d.ts","sourceRoot":"","sources":["../../../src/lib/services/schema-object-factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAO5B,OAAO,EACL,mBAAmB,EACnB,eAAe,EACf,eAAe,EACf,YAAY,EACb,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,mDAAmD,CAAC;AAMzF,OAAO,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAG/D,qBAAa,mBAAmB;IAE5B,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IACxC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;gBADlB,uBAAuB,EAAE,uBAAuB,EAChD,kBAAkB,EAAE,kBAAkB;IAGzD,eAAe,CACb,UAAU,EAAE,qBAAqB,EAAE,EACnC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GACpC,KAAK,CAAC,qBAAqB,GAAG,mBAAmB,CAAC;IA0BrD,aAAa,CAAC,KAAK,EAAE,qBAAqB,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BjF,OAAO,CAAC,wBAAwB;IAqBhC;;;;;OAKG;IACH,yBAAyB,CACvB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,EACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACrC,kBAAkB,GAAE,MAAM,EAAO;IAgCnC;;;;;OAKG;IACH,kBAAkB,CAChB,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,QAAQ,GAAG,SAAS,EAC1C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACrC,kBAAkB,GAAE,MAAM,EAAO,GAChC,MAAM;IAwCT,aAAa,CAAC,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC;IAW7C,yBAAyB,CACvB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACrC,iBAAiB,EAAE,MAAM,EAAE,EAC3B,QAAQ,CAAC,EAAE,oBAAoB,GAC9B,oBAAoB,GAAG,eAAe,GAAG,eAAe,GAAG,CAAC,YAAY,GAAG;QAAE,YAAY,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;IAkBzG,eAAe,CAAC,KAAK,EAAE,qBAAqB,GAAG,mBAAmB,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;IAqCzG,oBAAoB,CAClB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GACpC,oBAAoB;IA6CvB,6BAA6B,CAC3B,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,oBAAoB,EAC9B,gBAAgB,EAAE,OAAO,EACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACrC,iBAAiB,EAAE,MAAM,EAAE,GAC1B,oBAAoB;IAqCvB,8BAA8B,CAC5B,QAAQ,EAAE,oBAAoB,EAC9B,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAClC,oBAAoB;IAcvB,iBAAiB,CAAC,KAAK,EAAE,qBAAqB,GAAG,GAAG;IAYpD,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC;;;;;;IAyC3G,qBAAqB,CACnB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,EACrC,iBAAiB,EAAE,MAAM,EAAE;IAkB7B,OAAO,CAAC,oBAAoB;IAkG5B,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,eAAe;IAgBvB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,wBAAwB;CAQjC"}

package/dist/lib/services/schema-object-factory.js

@@ -0,0 +1,484 @@
+import { isUndefined } from '@nestjs/common/utils/shared.utils.js';
+import { flatten, isFunction, isString, keyBy, mapValues, omit, omitBy, pick } from 'lodash';
+import { DECORATORS } from '../constants.js';
+import { getTypeIsArrayTuple } from '../decorators/helpers.js';
+import { exploreGlobalApiExtraModelsMetadata } from '../explorers/api-extra-models.explorer.js';
+import { getSchemaPath } from '../utils/index.js';
+import { getEnumType, getEnumValues, isEnumArray, isEnumMetadata } from '../utils/enum.utils.js';
+import { isBodyParameter } from '../utils/is-body-parameter.util.js';
+import { isBuiltInType } from '../utils/is-built-in-type.util.js';
+import { isDateCtor } from '../utils/is-date-ctor.util.js';
+import { Cast } from 'vona';
+export class SchemaObjectFactory {
+    constructor(modelPropertiesAccessor, swaggerTypesMapper) {
+        Object.defineProperty(this, "modelPropertiesAccessor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: modelPropertiesAccessor
+        });
+        Object.defineProperty(this, "swaggerTypesMapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: swaggerTypesMapper
+        });
+    }
+    createFromModel(parameters, schemas) {
+        const parameterObjects = parameters.map(param => {
+            if (this.isLazyTypeFunc(param.type)) {
+                [param.type, param.isArray] = getTypeIsArrayTuple(param.type(), undefined);
+            }
+            if (!isBodyParameter(param) && param.enumName) {
+                return this.createEnumParam(param, schemas);
+            }
+            if (this.isPrimitiveType(param.type)) {
+                return param;
+            }
+            if (this.isArrayCtor(param.type)) {
+                return this.mapArrayCtorParam(param);
+            }
+            if (!isBodyParameter(param)) {
+                return this.createQueryOrParamSchema(param, schemas);
+            }
+            return this.getCustomType(param, schemas);
+        });
+        return flatten(parameterObjects);
+    }
+    getCustomType(param, schemas) {
+        const modelName = this.exploreModelSchema(param.type, schemas);
+        const name = param.name || modelName;
+        const schema = {
+            ...(param.schema || {}),
+            $ref: getSchemaPath(modelName),
+        };
+        const isArray = param.isArray;
+        param = omit(param, 'isArray');
+        if (isArray) {
+            return {
+                ...param,
+                name,
+                schema: {
+                    type: 'array',
+                    items: schema,
+                },
+            };
+        }
+        return {
+            ...param,
+            name,
+            schema,
+        };
+    }
+    createQueryOrParamSchema(param, schemas) {
+        if (isDateCtor(param.type)) {
+            return {
+                format: 'date-time',
+                ...param,
+                type: 'string',
+            };
+        }
+        if (this.isBigInt(param.type)) {
+            return {
+                format: 'int64',
+                ...param,
+                type: 'integer',
+            };
+        }
+        if (isFunction(param.type)) {
+            return this.getCustomType(param, schemas);
+        }
+        return param;
+    }
+    /**
+     *
+     * @param type
+     * @param schemas
+     * @param pendingSchemasRefs Used internally to avoid infinite recursion
+     */
+    extractPropertiesFromType(type, schemas, pendingSchemasRefs = []) {
+        const { prototype } = type;
+        if (!prototype) {
+            return;
+        }
+        const extraModels = exploreGlobalApiExtraModelsMetadata(type);
+        extraModels.forEach(item => this.exploreModelSchema(item, schemas, pendingSchemasRefs));
+        this.modelPropertiesAccessor.applyMetadataFactory(prototype);
+        const modelProperties = this.modelPropertiesAccessor.getModelProperties(prototype);
+        const propertiesWithType = modelProperties.map(key => {
+            const property = this.mergePropertyWithMetadata(key, prototype, schemas, pendingSchemasRefs);
+            const schemaCombinators = ['oneOf', 'anyOf', 'allOf'];
+            const declaredSchemaCombinator = schemaCombinators.find(combinator => combinator in property);
+            if (declaredSchemaCombinator) {
+                const schemaObjectMetadata = property;
+                if (schemaObjectMetadata?.type === 'array' || schemaObjectMetadata.isArray) {
+                    schemaObjectMetadata.items = {};
+                    schemaObjectMetadata.items[declaredSchemaCombinator] = property[declaredSchemaCombinator];
+                    delete property[declaredSchemaCombinator];
+                }
+                else {
+                    delete schemaObjectMetadata.type;
+                }
+            }
+            return property;
+        });
+        return propertiesWithType;
+    }
+    /**
+     *
+     * @param type
+     * @param schemas
+     * @param pendingSchemasRefs Used internally to avoid infinite recursion
+     */
+    exploreModelSchema(type, schemas, pendingSchemasRefs = []) {
+        if (this.isLazyTypeFunc(type)) {
+            type = type();
+        }
+        const propertiesWithType = this.extractPropertiesFromType(type, schemas, pendingSchemasRefs);
+        if (!propertiesWithType) {
+            return '';
+        }
+        const extensionProperties = Reflect.getMetadata(DECORATORS.API_EXTENSION, type) || {};
+        const typeDefinition = {
+            type: 'object',
+            properties: mapValues(keyBy(propertiesWithType, 'name'), property => {
+                const keysToOmit = ['name', 'isArray', 'enumName', 'enumSchema', 'selfRequired'];
+                if ('required' in property && Array.isArray(property.required)) {
+                    return omit(property, keysToOmit);
+                }
+                return omit(property, [...keysToOmit, 'required']);
+            }),
+            ...extensionProperties,
+        };
+        const typeDefinitionRequiredFields = propertiesWithType
+            .filter(property => (property.required != false && !Array.isArray(property.required)) ||
+            ('selfRequired' in property && property.selfRequired != false))
+            .map(property => property.name);
+        if (typeDefinitionRequiredFields.length > 0) {
+            typeDefinition['required'] = typeDefinitionRequiredFields;
+        }
+        const schemaName = this.getSchemaName(type);
+        schemas[schemaName] = typeDefinition;
+        return schemaName;
+    }
+    getSchemaName(type) {
+        const customSchema = Reflect.getOwnMetadata(DECORATORS.API_SCHEMA, type);
+        if (!customSchema || customSchema.length === 0) {
+            return Cast(type).name;
+        }
+        const schemaName = customSchema[0].name;
+        return schemaName ?? Cast(type).name;
+    }
+    mergePropertyWithMetadata(key, prototype, schemas, pendingSchemaRefs, metadata) {
+        if (!metadata) {
+            metadata = omit(Reflect.getMetadata(DECORATORS.API_MODEL_PROPERTIES, prototype, key), 'link') || {};
+        }
+        metadata = metadata;
+        if (this.isLazyTypeFunc(metadata.type)) {
+            metadata.type = metadata.type();
+            [metadata.type, metadata.isArray] = getTypeIsArrayTuple(metadata.type, metadata.isArray);
+        }
+        if (Array.isArray(metadata.type)) {
+            return this.createFromNestedArray(key, metadata, schemas, pendingSchemaRefs);
+        }
+        return this.createSchemaMetadata(key, metadata, schemas, pendingSchemaRefs);
+    }
+    createEnumParam(param, schemas) {
+        const enumName = param.enumName;
+        const $ref = getSchemaPath(enumName);
+        if (!(enumName in schemas)) {
+            const _enum = param.enum
+                ? param.enum
+                : param.schema
+                    ? param.schema['items']
+                        ? param.schema['items']['enum']
+                        : param.schema['enum']
+                    : param.isArray && param.items
+                        ? param.items.enum
+                        : undefined;
+            schemas[enumName] = {
+                type: (param.isArray ? param.schema?.['items']?.['type'] : param.schema?.['type']) ?? 'string',
+                enum: _enum,
+                ...param.enumSchema,
+                ...(param['x-enumNames'] ? { 'x-enumNames': param['x-enumNames'] } : {}),
+            };
+        }
+        else {
+            // Enum type is already defined so grab it and
+            // assign additional metadata if specified
+            if (param.enumSchema) {
+                schemas[enumName] = {
+                    ...schemas[enumName],
+                    ...param.enumSchema,
+                };
+            }
+        }
+        param.schema = param.isArray || param.schema?.['items'] ? { type: 'array', items: { $ref } } : { $ref };
+        return omit(param, ['isArray', 'items', 'enumName', 'enum', 'x-enumNames', 'enumSchema']);
+    }
+    createEnumSchemaType(key, metadata, schemas) {
+        if (!('enumName' in metadata) || !metadata.enumName) {
+            return {
+                ...metadata,
+                name: metadata.name || key,
+            };
+        }
+        const enumName = metadata.enumName;
+        const $ref = getSchemaPath(enumName);
+        const enumType = (metadata.isArray ? metadata.items?.['type'] : metadata.type) ?? 'string';
+        if (!schemas[enumName]) {
+            schemas[enumName] = {
+                type: enumType,
+                ...metadata.enumSchema,
+                enum: metadata.isArray && metadata.items ? metadata.items['enum'] : metadata.enum,
+            };
+        }
+        else {
+            if (metadata.enumSchema) {
+                schemas[enumName] = {
+                    ...schemas[enumName],
+                    ...metadata.enumSchema,
+                };
+            }
+        }
+        const _schemaObject = {
+            ...metadata,
+            name: metadata.name || key,
+            type: metadata.isArray ? 'array' : 'string',
+        };
+        const refHost = metadata.isArray ? { items: { $ref } } : { allOf: [{ $ref }] };
+        const paramObject = { ..._schemaObject, ...refHost };
+        const pathsToOmit = ['enum', 'enumName', 'enumSchema'];
+        if (!metadata.isArray) {
+            pathsToOmit.push('type');
+        }
+        return omit(paramObject, pathsToOmit);
+    }
+    createNotBuiltInTypeReference(key, metadata, trueMetadataType, schemas, pendingSchemaRefs) {
+        if (isUndefined(trueMetadataType)) {
+            throw new Error(`A circular dependency has been detected (property key: "${key}"). Please, make sure that each side of a bidirectional relationships are using lazy resolvers ("type: () => ClassType").`);
+        }
+        let schemaObjectName = trueMetadataType.name;
+        if (!(schemaObjectName in schemas) && !pendingSchemaRefs.includes(schemaObjectName)) {
+            schemaObjectName = this.exploreModelSchema(trueMetadataType, schemas, [
+                ...pendingSchemaRefs,
+                schemaObjectName,
+            ]);
+        }
+        const $ref = getSchemaPath(schemaObjectName);
+        if (metadata.isArray) {
+            return this.transformToArraySchemaProperty(metadata, key, { $ref });
+        }
+        const keysToRemove = ['type', 'isArray', 'required', 'name'];
+        const validMetadataObject = omit(metadata, keysToRemove);
+        const extraMetadataKeys = Object.keys(validMetadataObject);
+        if (extraMetadataKeys.length > 0) {
+            return {
+                name: metadata.name || key,
+                required: metadata.required,
+                ...validMetadataObject,
+                allOf: [{ $ref }],
+            };
+        }
+        return {
+            name: metadata.name || key,
+            required: metadata.required,
+            $ref,
+        };
+    }
+    transformToArraySchemaProperty(metadata, key, type) {
+        const keysToRemove = ['type', 'enum'];
+        const [movedProperties, keysToMove] = this.extractPropertyModifiers(metadata);
+        const schemaHost = {
+            ...omit(metadata, [...keysToRemove, ...keysToMove]),
+            name: metadata.name || key,
+            type: 'array',
+            items: isString(type) ? { type, ...movedProperties } : { ...Cast(type), ...movedProperties },
+        };
+        schemaHost.items = omitBy(schemaHost.items, isUndefined);
+        return schemaHost;
+    }
+    mapArrayCtorParam(param) {
+        return {
+            ...omit(param, 'type'),
+            schema: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                },
+            },
+        };
+    }
+    createFromObjectLiteral(key, literalObj, schemas) {
+        const objLiteralKeys = Object.keys(literalObj);
+        const properties = {};
+        const required = [];
+        objLiteralKeys.forEach(key => {
+            const propertyCompilerMetadata = literalObj[key];
+            if (isEnumArray(propertyCompilerMetadata)) {
+                propertyCompilerMetadata.type = 'array';
+                const enumValues = getEnumValues(propertyCompilerMetadata.enum);
+                propertyCompilerMetadata.items = {
+                    type: getEnumType(enumValues),
+                    enum: enumValues,
+                };
+                delete propertyCompilerMetadata.enum;
+            }
+            else if (propertyCompilerMetadata.enum) {
+                const enumValues = getEnumValues(propertyCompilerMetadata.enum);
+                propertyCompilerMetadata.enum = enumValues;
+                propertyCompilerMetadata.type = getEnumType(enumValues);
+            }
+            const propertyMetadata = this.mergePropertyWithMetadata(key, Object, schemas, [], propertyCompilerMetadata);
+            if ('required' in propertyMetadata && propertyMetadata.required) {
+                required.push(key);
+            }
+            const keysToRemove = ['isArray', 'name', 'required'];
+            const validMetadataObject = omit(propertyMetadata, keysToRemove);
+            properties[key] = validMetadataObject;
+        });
+        const schema = {
+            name: key,
+            type: 'object',
+            properties,
+            required,
+        };
+        return schema;
+    }
+    createFromNestedArray(key, metadata, schemas, pendingSchemaRefs) {
+        const recurse = (type) => {
+            if (!Array.isArray(type)) {
+                const schemaMetadata = this.createSchemaMetadata(key, metadata, schemas, pendingSchemaRefs, type);
+                return omit(schemaMetadata, ['isArray', 'name']);
+            }
+            return {
+                name: key,
+                type: 'array',
+                items: recurse(type[0]),
+            };
+        };
+        return recurse(metadata.type);
+    }
+    createSchemaMetadata(key, metadata, schemas, pendingSchemaRefs, nestedArrayType) {
+        const typeRef = nestedArrayType || metadata.type;
+        if (this.isObjectLiteral(typeRef)) {
+            const schemaFromObjectLiteral = this.createFromObjectLiteral(key, typeRef, schemas);
+            return {
+                ...schemaFromObjectLiteral,
+                selfRequired: metadata.required,
+            };
+        }
+        if (isString(typeRef)) {
+            if (isEnumMetadata(metadata)) {
+                return this.createEnumSchemaType(key, metadata, schemas);
+            }
+            if (metadata.isArray) {
+                return this.transformToArraySchemaProperty(metadata, key, typeRef);
+            }
+            return {
+                ...metadata,
+                name: metadata.name || key,
+            };
+        }
+        if (isDateCtor(typeRef)) {
+            if (metadata.isArray) {
+                return this.transformToArraySchemaProperty(metadata, key, {
+                    format: metadata.format || 'date-time',
+                    type: 'string',
+                });
+            }
+            return {
+                format: 'date-time',
+                ...metadata,
+                type: 'string',
+                name: metadata.name || key,
+            };
+        }
+        if (this.isBigInt(typeRef)) {
+            return {
+                format: 'int64',
+                ...metadata,
+                type: 'integer',
+                name: metadata.name || key,
+            };
+        }
+        if (!isBuiltInType(typeRef)) {
+            return this.createNotBuiltInTypeReference(key, metadata, typeRef, schemas, pendingSchemaRefs);
+        }
+        const typeName = this.getTypeName(typeRef);
+        const itemType = this.swaggerTypesMapper.mapTypeToOpenAPIType(typeName);
+        if (metadata.isArray) {
+            return this.transformToArraySchemaProperty(metadata, key, {
+                type: itemType,
+            });
+        }
+        else if (itemType === 'array') {
+            const defaultOnArray = 'string';
+            // Check if the schema has a combinator because if so
+            // we should not auto-wrap the type in an array
+            //
+            // Example:
+            // @ApiProperty({
+            //   oneOf: [
+            //     { type: 'array', items: { type: 'string' } },
+            //     { type: 'array', items: { type: 'number' } },
+            //     { type: 'array', items: { type: 'boolean' } }
+            //   ],
+            // })
+            // attribute: string[] | number[] | boolean[];
+            //
+            // this should not produce an array of arrays
+            const hasSchemaCombinator = ['oneOf', 'anyOf', 'allOf'].some(combinator => combinator in metadata);
+            if (hasSchemaCombinator) {
+                return {
+                    ...metadata,
+                    type: undefined,
+                    name: metadata.name || key,
+                };
+            }
+            return this.transformToArraySchemaProperty(metadata, key, {
+                type: defaultOnArray,
+            });
+        }
+        return {
+            ...metadata,
+            name: metadata.name || key,
+            type: itemType,
+        };
+    }
+    isArrayCtor(type) {
+        return type === Array;
+    }
+    isPrimitiveType(type) {
+        return isFunction(type) && [String, Boolean, Number].some(item => item === type);
+    }
+    isLazyTypeFunc(type) {
+        return isFunction(type) && Cast(type).name == 'type';
+    }
+    getTypeName(type) {
+        return type && isFunction(type) ? Cast(type).name : type;
+    }
+    isObjectLiteral(obj) {
+        if (typeof obj !== 'object' || !obj) {
+            return false;
+        }
+        const hasOwnProp = Object.prototype.hasOwnProperty;
+        let objPrototype = obj;
+        while (Object.getPrototypeOf((objPrototype = Object.getPrototypeOf(objPrototype))) !== null)
+            ;
+        for (const prop in obj) {
+            if (!hasOwnProp.call(obj, prop) && !hasOwnProp.call(objPrototype, prop)) {
+                return false;
+            }
+        }
+        return Object.getPrototypeOf(obj) === objPrototype;
+    }
+    isBigInt(type) {
+        return type === BigInt;
+    }
+    extractPropertyModifiers(metadata) {
+        const modifierKeys = ['format', 'maximum', 'maxLength', 'minimum', 'minLength', 'pattern'];
+        return [pick(metadata, modifierKeys), modifierKeys];
+    }
+}
+//# sourceMappingURL=schema-object-factory.js.map