parse-openapi/dist/parser/getModel.js

OpenAPI v3 parser

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getModel = void 0;
const getPattern_1 = require("../utils/getPattern");
const getEnum_1 = require("./getEnum");
const getEnumFromDescription_1 = require("./getEnumFromDescription");
const getModelComposition_1 = require("./getModelComposition");
const getModelDefault_1 = require("./getModelDefault");
const getModelProperties_1 = require("./getModelProperties");
const getType_1 = require("./getType");
const getModel = (openApi, definition, isDefinition = false, name = '') => {
    const model = {
        name,
        export: 'interface',
        type: 'any',
        base: 'any',
        template: null,
        link: null,
        description: definition.description || null,
        isDefinition,
        isReadOnly: definition.readOnly === true,
        isNullable: definition.nullable === true,
        isRequired: false,
        format: definition.format,
        maximum: definition.maximum,
        exclusiveMaximum: definition.exclusiveMaximum,
        minimum: definition.minimum,
        exclusiveMinimum: definition.exclusiveMinimum,
        multipleOf: definition.multipleOf,
        maxLength: definition.maxLength,
        minLength: definition.minLength,
        maxItems: definition.maxItems,
        minItems: definition.minItems,
        uniqueItems: definition.uniqueItems,
        maxProperties: definition.maxProperties,
        minProperties: definition.minProperties,
        pattern: (0, getPattern_1.getPattern)(definition.pattern),
        imports: [],
        enum: [],
        enums: [],
        properties: [],
    };
    if (definition.$ref) {
        const definitionRef = (0, getType_1.getType)(definition.$ref);
        model.export = 'reference';
        model.type = definitionRef.type;
        model.base = definitionRef.base;
        model.template = definitionRef.template;
        model.imports.push(...definitionRef.imports);
        model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
        return model;
    }
    if (definition.enum && definition.type !== 'boolean') {
        const enumerators = (0, getEnum_1.getEnum)(definition.enum);
        if (enumerators.length) {
            model.export = 'enum';
            model.type = 'string';
            model.base = 'string';
            model.enum.push(...enumerators);
            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
            return model;
        }
    }
    if ((definition.type === 'int' || definition.type === 'integer') && definition.description) {
        const enumerators = (0, getEnumFromDescription_1.getEnumFromDescription)(definition.description);
        if (enumerators.length) {
            model.export = 'enum';
            model.type = 'number';
            model.base = 'number';
            model.enum.push(...enumerators);
            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
            return model;
        }
    }
    if (definition.type === 'array' && definition.items) {
        if (definition.items.$ref) {
            const arrayItems = (0, getType_1.getType)(definition.items.$ref);
            model.export = 'array';
            model.type = arrayItems.type;
            model.base = arrayItems.base;
            model.template = arrayItems.template;
            model.imports.push(...arrayItems.imports);
            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
            return model;
        }
        else {
            const arrayItems = (0, exports.getModel)(openApi, definition.items);
            model.export = 'array';
            model.type = arrayItems.type;
            model.base = arrayItems.base;
            model.template = arrayItems.template;
            model.link = arrayItems;
            model.imports.push(...arrayItems.imports);
            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
            return model;
        }
    }
    if (definition.type === 'object' && typeof definition.additionalProperties === 'object') {
        if (definition.additionalProperties.$ref) {
            const additionalProperties = (0, getType_1.getType)(definition.additionalProperties.$ref);
            model.export = 'dictionary';
            model.type = additionalProperties.type;
            model.base = additionalProperties.base;
            model.template = additionalProperties.template;
            model.imports.push(...additionalProperties.imports);
            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
            return model;
        }
        else {
            const additionalProperties = (0, exports.getModel)(openApi, definition.additionalProperties);
            model.export = 'dictionary';
            model.type = additionalProperties.type;
            model.base = additionalProperties.base;
            model.template = additionalProperties.template;
            model.link = additionalProperties;
            model.imports.push(...additionalProperties.imports);
            model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
            return model;
        }
    }
    if (definition.oneOf?.length) {
        const composition = (0, getModelComposition_1.getModelComposition)(openApi, definition, definition.oneOf, 'one-of', exports.getModel);
        model.export = composition.type;
        model.imports.push(...composition.imports);
        model.properties.push(...composition.properties);
        model.enums.push(...composition.enums);
        return model;
    }
    if (definition.anyOf?.length) {
        const composition = (0, getModelComposition_1.getModelComposition)(openApi, definition, definition.anyOf, 'any-of', exports.getModel);
        model.export = composition.type;
        model.imports.push(...composition.imports);
        model.properties.push(...composition.properties);
        model.enums.push(...composition.enums);
        return model;
    }
    if (definition.allOf?.length) {
        const composition = (0, getModelComposition_1.getModelComposition)(openApi, definition, definition.allOf, 'all-of', exports.getModel);
        model.export = composition.type;
        model.imports.push(...composition.imports);
        model.properties.push(...composition.properties);
        model.enums.push(...composition.enums);
        return model;
    }
    if (definition.type === 'object') {
        model.export = 'interface';
        model.type = 'any';
        model.base = 'any';
        model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
        if (definition.properties) {
            const modelProperties = (0, getModelProperties_1.getModelProperties)(openApi, definition, exports.getModel, model);
            modelProperties.forEach(modelProperty => {
                model.imports.push(...modelProperty.imports);
                model.enums.push(...modelProperty.enums);
                model.properties.push(modelProperty);
                if (modelProperty.export === 'enum') {
                    model.enums.push(modelProperty);
                }
            });
        }
        return model;
    }
    // If the schema has a type than it can be a basic or generic type.
    if (definition.type) {
        const definitionType = (0, getType_1.getType)(definition.type, definition.format);
        model.export = 'generic';
        model.type = definitionType.type;
        model.base = definitionType.base;
        model.template = definitionType.template;
        model.isNullable = definitionType.isNullable || model.isNullable;
        model.imports.push(...definitionType.imports);
        model.default = (0, getModelDefault_1.getModelDefault)(definition, model);
        return model;
    }
    return model;
};
exports.getModel = getModel;