@goast/kotlin 0.6.0 → 0.7.0-beta.1

package/script/src/generators/models/model-generator.js

@@ -1,645 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultKotlinModelGenerator = void 0;
-const core_1 = require("@goast/core");
-const index_js_1 = require("../../ast/index.js");
-const file_builder_js_1 = require("../../file-builder.js");
-const utils_js_1 = require("../../utils.js");
-const file_generator_js_1 = require("../file-generator.js");
-class DefaultKotlinModelGenerator extends file_generator_js_1.KotlinFileGenerator {
-    generate(ctx) {
-        if (/\/(anyOf|allOf)(\/[0-9]+)?$/.test(ctx.schema.$src.path)) {
-            // Do not generate types that are only used for anyOf and/or allOf
-            return { type: index_js_1.kt.refs.any({ nullable: true }) };
-        }
-        const schemaReference = (0, core_1.getSchemaReference)(ctx.schema, core_1.DEFAULT_IGNORED_SCHEMA_PROPERTIES);
-        if (schemaReference !== ctx.schema) {
-            const typeName = this.getDeclarationTypeName(ctx, { schema: schemaReference });
-            const packageName = this.getPackageName(ctx, { schema: schemaReference });
-            return { type: index_js_1.kt.reference(typeName, packageName) };
-        }
-        if (this.shouldGenerateTypeDeclaration(ctx, { schema: ctx.schema })) {
-            const typeName = this.getDeclarationTypeName(ctx, { schema: ctx.schema });
-            const packageName = this.getPackageName(ctx, { schema: ctx.schema });
-            const filePath = `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}/${typeName}.kt`;
-            console.log(`Generating model ${(0, core_1.getSourceDisplayName)(ctx.data, ctx.schema)} [${packageName}.${typeName}] to ${filePath}...`);
-            const builder = new file_builder_js_1.KotlinFileBuilder(packageName, ctx.config);
-            builder.append(this.getFileContent(ctx, {}));
-            builder.writeToFile(filePath);
-            return { type: index_js_1.kt.reference(typeName, packageName) };
-        }
-        else {
-            return { type: this.getType(ctx, { schema: ctx.schema }) };
-        }
-    }
-    getFileContent(ctx, _args) {
-        return (0, core_1.appendValueGroup)([this.getSchemaDeclaration(ctx, { schema: this.normalizeSchema(ctx, { schema: ctx.schema }) })], '\n\n');
-    }
-    getSchemaDeclaration(ctx, args) {
-        const { schema } = args;
-        if (schema.kind === 'object') {
-            return schema.discriminator ? this.getInterface(ctx, { schema }) : this.getClass(ctx, { schema });
-        }
-        else if (schema.enum !== undefined && schema.enum.length > 0) {
-            return this.getEnum(ctx, { schema });
-        }
-        return '// The generator was not able to generate this schema.\n// This should not happend. If you see this comment, please open an Issue on Github.';
-    }
-    getClass(ctx, args) {
-        const { schema } = args;
-        const inheritedSchemas = this.getInheritedSchemas(ctx, { schema });
-        const parameters = this.getClassProperties(ctx, { schema });
-        return index_js_1.kt.class(this.getDeclarationTypeName(ctx, { schema }), {
-            doc: index_js_1.kt.doc(this.getSchemaDocDescription(ctx, { schema })),
-            annotations: [
-                this.getJacksonJsonClassDescriptionAnnotation(ctx, { schema }),
-                schema.deprecated ? index_js_1.kt.annotation(index_js_1.kt.refs.deprecated(), [index_js_1.kt.argument(index_js_1.kt.string(''))]) : null,
-            ],
-            classKind: parameters.length === 0 ? null : 'data',
-            implements: inheritedSchemas.map((schema) => this.getType(ctx, { schema, nullable: false })),
-            primaryConstructor: index_js_1.kt.constructor(parameters.map((property) => this.getClassParameter(ctx, { ...args, inheritedSchemas, parameters, property }))),
-            members: [
-                ...(schema.additionalProperties !== undefined && schema.additionalProperties !== false
-                    ? [
-                        this.getAdditionalPropertiesProperty(ctx, { schema }),
-                        this.getAdditionalPropertiesSetter(ctx, { schema }),
-                        this.getAdditionalPropertiesGetter(ctx, { schema }),
-                    ]
-                    : []),
-            ],
-        });
-    }
-    getInterface(ctx, args) {
-        const { schema } = args;
-        return index_js_1.kt.interface(this.getDeclarationTypeName(ctx, { schema }), {
-            doc: index_js_1.kt.doc(this.getSchemaDocDescription(ctx, { schema })),
-            annotations: [
-                this.getJacksonJsonTypeInfoAnnotation(ctx, { schema }),
-                this.getJacksonJsonSubTypesAnnotation(ctx, { schema }),
-                this.getJacksonJsonClassDescriptionAnnotation(ctx, { schema }),
-                schema.deprecated ? index_js_1.kt.annotation(index_js_1.kt.refs.deprecated(), [index_js_1.kt.argument(index_js_1.kt.string(''))]) : null,
-            ].filter(core_1.notNullish),
-            members: this.sortProperties(ctx, { schema, properties: schema.properties.values() }).map((property) => this.getInterfaceProperty(ctx, { schema, property })),
-        });
-    }
-    getEnum(ctx, args) {
-        var _a, _b, _c;
-        const { schema } = args;
-        const name = this.getDeclarationTypeName(ctx, { schema });
-        // One set of names for both generation sites below, so the constant and its `when` branch agree.
-        const valueNames = this.toEnumValueNames(ctx, schema.enum);
-        return index_js_1.kt.enum(name, (_b = (_a = schema.enum) === null || _a === void 0 ? void 0 : _a.map((x, i) => index_js_1.kt.enumValue(valueNames[i], {
-            annotations: [index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonProperty(), [index_js_1.kt.argument(index_js_1.kt.string(String(x)))])],
-            arguments: [index_js_1.kt.argument(index_js_1.kt.string(String(x)))],
-        }))) !== null && _b !== void 0 ? _b : [], {
-            doc: index_js_1.kt.doc(this.getSchemaDocDescription(ctx, { schema })),
-            annotations: [schema.deprecated ? index_js_1.kt.annotation(index_js_1.kt.refs.deprecated(), [index_js_1.kt.argument(index_js_1.kt.string(''))]) : null],
-            primaryConstructor: index_js_1.kt.constructor([
-                index_js_1.kt.parameter.class((0, core_1.toCasing)('value', ctx.config.propertyNameCasing), index_js_1.kt.refs.string(), {
-                    property: 'readonly',
-                }),
-            ]),
-            companionObject: index_js_1.kt.object({
-                members: [
-                    index_js_1.kt.function('fromValue', {
-                        parameters: [index_js_1.kt.parameter('value', index_js_1.kt.refs.string())],
-                        returnType: index_js_1.kt.reference(name, null, { nullable: true }),
-                        singleExpression: true,
-                        body: !((_c = schema.enum) === null || _c === void 0 ? void 0 : _c.length) ? 'null' : (0, core_1.builderTemplate) `\nwhen(value) {${core_1.builderTemplate.indent `${(0, core_1.appendValueGroup)([
-                            schema.enum.map((x, i) => (0, core_1.builderTemplate) `\n${index_js_1.kt.string(String(x))} -> ${valueNames[i]}`),
-                        ])}
-                else -> null`}
-              }`,
-                    }),
-                ],
-            }),
-        });
-    }
-    getSchemaDocDescription(ctx, args) {
-        var _a;
-        const docSegments = [(_a = args.schema.description) === null || _a === void 0 ? void 0 : _a.trim()];
-        if (ctx.config.includeSourceInDocs) {
-            docSegments.push((0, utils_js_1.getSourceDocLine)(args.schema));
-        }
-        return docSegments.filter(core_1.notNullish).join('\n\n');
-    }
-    getType(ctx, args) {
-        let { schema, nullable } = args;
-        if (schema.kind === 'oneOf' && schema.oneOf.length === 2 && schema.oneOf.some((x) => x.kind === 'null')) {
-            const nonNullSchema = schema.oneOf.find((x) => x.kind !== 'null');
-            if (nonNullSchema) {
-                schema = nonNullSchema;
-                nullable !== null && nullable !== void 0 ? nullable : (nullable = true);
-            }
-        }
-        const generatedType = this.getGeneratedType(ctx, { schema, nullable });
-        if (generatedType) {
-            return generatedType;
-        }
-        nullable !== null && nullable !== void 0 ? nullable : (nullable = schema.nullable);
-        switch (schema.kind) {
-            case 'boolean':
-                return index_js_1.kt.refs.boolean({ nullable });
-            case 'integer':
-            case 'number':
-                switch (schema.format) {
-                    case 'int32':
-                        return index_js_1.kt.refs.int({ nullable });
-                    case 'int64':
-                        return index_js_1.kt.refs.long({ nullable });
-                    case 'float':
-                        return index_js_1.kt.refs.float({ nullable });
-                    case 'double':
-                        return index_js_1.kt.refs.double({ nullable });
-                    default:
-                        return schema.kind === 'integer' ? index_js_1.kt.refs.int({ nullable }) : index_js_1.kt.refs.double({ nullable });
-                }
-            case 'string':
-                switch (schema.format) {
-                    case 'date-time':
-                        return index_js_1.kt.refs.java.offsetDateTime({ nullable });
-                    case 'time':
-                        return index_js_1.kt.refs.java.offsetTime({ nullable });
-                    case 'date':
-                        return index_js_1.kt.refs.java.localDate({ nullable });
-                    case 'local-date-time':
-                        return index_js_1.kt.refs.java.localDateTime({ nullable });
-                    case 'local-time':
-                        return index_js_1.kt.refs.java.localTime({ nullable });
-                    case 'uri':
-                        return index_js_1.kt.refs.java.uri({ nullable });
-                    default:
-                        return index_js_1.kt.refs.string({ nullable });
-                }
-            case 'null':
-                return index_js_1.kt.refs.nothing({ nullable });
-            case 'unknown':
-                return index_js_1.kt.refs.any({ nullable });
-            case 'array':
-                return index_js_1.kt.refs.list([schema.items ? this.getType(ctx, { schema: schema.items }) : index_js_1.kt.refs.any({ nullable: true })], { nullable });
-            case 'object':
-                return schema.properties.size === 0 && schema.additionalProperties
-                    ? index_js_1.kt.refs.map([index_js_1.kt.refs.string(), this.getAdditionalPropertiesType(ctx, { schema })], { nullable })
-                    : index_js_1.kt.refs.any({ nullable });
-            default:
-                return index_js_1.kt.refs.any({ nullable });
-        }
-    }
-    getGeneratedType(ctx, args) {
-        var _a;
-        const schema = (0, core_1.getSchemaReference)(args.schema, core_1.DEFAULT_IGNORED_SCHEMA_PROPERTIES);
-        if (this.shouldGenerateTypeDeclaration(ctx, { schema })) {
-            return index_js_1.kt.reference(this.getDeclarationTypeName(ctx, { schema }), this.getPackageName(ctx, { schema }), {
-                nullable: (_a = args.nullable) !== null && _a !== void 0 ? _a : schema.nullable,
-            });
-        }
-        return null;
-    }
-    getAdditionalPropertiesType(ctx, args) {
-        const { schema } = args;
-        return typeof schema.additionalProperties === 'object'
-            ? this.getType(ctx, { schema: schema.additionalProperties })
-            : index_js_1.kt.refs.any({ nullable: true });
-    }
-    getDefaultValue(ctx, args) {
-        const { schema } = args;
-        if (schema.default === null || schema.default === undefined) {
-            return 'null';
-        }
-        else {
-            switch (schema.kind) {
-                case 'boolean':
-                    return Boolean(schema.default) || String(schema.default).toLowerCase() === 'true' ? 'true' : 'false';
-                case 'integer':
-                case 'number':
-                    return String(schema.default);
-                case 'string':
-                    return schema.enum && schema.enum.length > 0
-                        ? index_js_1.kt.call([this.getType(ctx, { schema }), this.toEnumValueName(ctx, schema.enum, schema.default)])
-                        : index_js_1.kt.string(String(schema.default));
-                case 'array': {
-                    const itemEnumSchema = (0, utils_js_1.getStringEnumSchema)(schema.items);
-                    return index_js_1.kt.call(index_js_1.kt.refs.listOf.infer(), Array.isArray(schema.default)
-                        ? schema.default.map((x) => itemEnumSchema
-                            ? index_js_1.kt.call([
-                                this.getType(ctx, { schema: itemEnumSchema }),
-                                this.toEnumValueName(ctx, itemEnumSchema.enum, x),
-                            ])
-                            : index_js_1.kt.toNode(x))
-                        : []);
-                }
-                default:
-                    return 'null';
-            }
-        }
-    }
-    // #region Members
-    getClassParameter(ctx, args) {
-        var _a;
-        const { schema, inheritedSchemas, property } = args;
-        return index_js_1.kt.parameter.class((0, core_1.toCasing)(property.name, ctx.config.propertyNameCasing), this.getType(ctx, { schema: property.schema, nullable: schema.required.has(property.name) ? undefined : true }), {
-            description: (_a = property.schema.description) === null || _a === void 0 ? void 0 : _a.trim(),
-            annotations: [
-                ...this.getJakartaValidationAnnotations(ctx, { schema, property }),
-                this.getSwaggerSchemaAnnotation(ctx, { schema, property }),
-                (0, core_1.modify)(this.getJacksonJsonPropertyAnnotation(ctx, { schema, property }), (x) => (x.target = 'param')),
-                ...(0, core_1.modifyEach)([
-                    this.getJacksonJsonPropertyAnnotation(ctx, { schema, property }),
-                    this.getJacksonJsonPropertyDescriptionAnnotation(ctx, { schema, property }),
-                    this.getJacksonJsonIncludeAnnotation(ctx, { schema, property }),
-                ].filter(core_1.notNullish), (x) => (x.target = 'get')),
-                property.schema.deprecated ? index_js_1.kt.annotation(index_js_1.kt.refs.deprecated(), [index_js_1.kt.argument(index_js_1.kt.string(''))]) : null,
-            ].filter(core_1.notNullish),
-            override: inheritedSchemas.some((schema) => this.hasProperty(ctx, { schema, propertyName: property.name })),
-            property: 'readonly',
-            default: property.schema.default !== undefined || !schema.required.has(property.name)
-                ? this.getDefaultValue(ctx, { schema: property.schema })
-                : null,
-        });
-    }
-    getInterfaceProperty(ctx, args) {
-        const { schema, property } = args;
-        return index_js_1.kt.property((0, core_1.toCasing)(property.name, ctx.config.propertyNameCasing), {
-            doc: index_js_1.kt.doc(this.getSchemaDocDescription(ctx, { schema: property.schema })),
-            annotations: (0, core_1.modifyEach)([
-                this.getJacksonJsonPropertyAnnotation(ctx, { schema, property }),
-                this.getJacksonJsonPropertyDescriptionAnnotation(ctx, { schema, property }),
-                this.getJacksonJsonIncludeAnnotation(ctx, { schema, property }),
-                property.schema.deprecated ? index_js_1.kt.annotation(index_js_1.kt.refs.deprecated(), [index_js_1.kt.argument(index_js_1.kt.string(''))]) : null,
-            ].filter(core_1.notNullish), (x) => (x.target = 'get')),
-            type: this.getType(ctx, {
-                schema: property.schema,
-                nullable: schema.required.has(property.name) ? undefined : true,
-            }),
-        });
-    }
-    getAdditionalPropertiesProperty(ctx, args) {
-        const { schema } = args;
-        return index_js_1.kt.property((0, core_1.toCasing)('additionalProperties', ctx.config.propertyNameCasing), {
-            annotations: [index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonIgnore())],
-            type: index_js_1.kt.reference('MutableMap', null, {
-                generics: ['String', this.getAdditionalPropertiesType(ctx, { schema })],
-            }),
-            default: 'mutableMapOf()',
-        });
-    }
-    getAdditionalPropertiesSetter(ctx, args) {
-        const { schema } = args;
-        return index_js_1.kt.function((0, core_1.toCasing)('set', ctx.config.functionNameCasing), {
-            annotations: [index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonAnySetter())],
-            parameters: [
-                index_js_1.kt.parameter((0, core_1.toCasing)('name', ctx.config.parameterNameCasing), 'String'),
-                index_js_1.kt.parameter((0, core_1.toCasing)('value', ctx.config.parameterNameCasing), this.getAdditionalPropertiesType(ctx, { schema })),
-            ],
-            body: `this.${(0, core_1.toCasing)('additionalProperties', ctx.config.propertyNameCasing)}[name] = value`,
-        });
-    }
-    getAdditionalPropertiesGetter(ctx, args) {
-        const { schema } = args;
-        return index_js_1.kt.function((0, core_1.toCasing)('getMap', ctx.config.functionNameCasing), {
-            annotations: [index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonAnyGetter())],
-            returnType: index_js_1.kt.refs.map([index_js_1.kt.refs.string(), this.getAdditionalPropertiesType(ctx, { schema })]),
-            body: `return this.${(0, core_1.toCasing)('additionalProperties', ctx.config.propertyNameCasing)}`,
-        });
-    }
-    // #endregion
-    // #region Annotations
-    getJacksonJsonTypeInfoAnnotation(ctx, args) {
-        const { schema } = args;
-        return ctx.config.addJacksonAnnotations && schema.discriminator
-            ? index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonTypeInfo(), [
-                index_js_1.kt.argument.named('use', 'JsonTypeInfo.Id.NAME'),
-                index_js_1.kt.argument.named('include', 'properties' in schema && schema.properties.has(schema.discriminator.propertyName)
-                    ? 'JsonTypeInfo.As.EXISTING_PROPERTY'
-                    : 'JsonTypeInfo.As.PROPERTY'),
-                index_js_1.kt.argument.named('property', index_js_1.kt.string(schema.discriminator.propertyName)),
-                index_js_1.kt.argument.named('visible', 'true'),
-            ])
-            : null;
-    }
-    getJacksonJsonSubTypesAnnotation(ctx, args) {
-        const { schema } = args;
-        if (!ctx.config.addJacksonAnnotations || !schema.discriminator)
-            return null;
-        const entries = Object.entries(schema.discriminator.mapping);
-        return entries.length > 0
-            ? index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonSubTypes(), entries.map(([value, schema]) => index_js_1.kt.argument(index_js_1.kt.call([index_js_1.kt.refs.jackson.jsonSubTypes(), 'Type'], [
-                index_js_1.kt.argument.named('value', (0, core_1.modify)(this.getType(ctx, { schema }), (x) => (x.classReference = true))),
-                index_js_1.kt.argument.named('name', index_js_1.kt.string(value)),
-            ]))))
-            : null;
-    }
-    getJacksonJsonClassDescriptionAnnotation(ctx, args) {
-        const { schema } = args;
-        return ctx.config.addJacksonAnnotations && schema.description
-            ? index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonClassDescription(), [
-                index_js_1.kt.argument(index_js_1.kt.string(schema.description)),
-            ])
-            : null;
-    }
-    getJacksonJsonPropertyAnnotation(ctx, args) {
-        const { schema, property } = args;
-        return ctx.config.addJacksonAnnotations
-            ? index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonProperty(), [
-                index_js_1.kt.argument(index_js_1.kt.string(property.name)),
-                schema.required.has(property.name) ? index_js_1.kt.argument.named('required', 'true') : null,
-            ])
-            : null;
-    }
-    getJacksonJsonPropertyDescriptionAnnotation(ctx, args) {
-        const { property } = args;
-        return ctx.config.addJacksonAnnotations && property.schema.description
-            ? index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonPropertyDescription(), [
-                index_js_1.kt.argument(index_js_1.kt.string(property.schema.description)),
-            ])
-            : null;
-    }
-    getJacksonJsonIncludeAnnotation(ctx, args) {
-        const { property } = args;
-        return ctx.config.addJacksonAnnotations && property.schema.custom['exclude-when-null'] === true
-            ? index_js_1.kt.annotation(index_js_1.kt.refs.jackson.jsonInclude(), [
-                index_js_1.kt.argument(index_js_1.kt.call([index_js_1.kt.refs.jackson.jsonInclude(), 'Include', 'NON_NULL'])),
-            ])
-            : null;
-    }
-    getJakartaValidationAnnotations(ctx, args) {
-        const { property } = args;
-        const annotations = [];
-        if (!ctx.config.addJakartaValidationAnnotations) {
-            return annotations;
-        }
-        if (property.schema.kind === 'string') {
-            if (property.schema.pattern) {
-                annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.pattern(), [index_js_1.kt.argument.named('regexp', index_js_1.kt.string(property.schema.pattern))], {
-                    target: 'get',
-                }));
-            }
-            if (property.schema.minLength === 1 && property.schema.maxLength === undefined) {
-                annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.notEmpty(), [], { target: 'get' }));
-            }
-            else if (property.schema.minLength !== undefined || property.schema.maxLength !== undefined) {
-                annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.size(), [
-                    property.schema.minLength !== undefined ? index_js_1.kt.argument.named('min', property.schema.minLength) : null,
-                    property.schema.maxLength !== undefined ? index_js_1.kt.argument.named('max', property.schema.maxLength) : null,
-                ], { target: 'get' }));
-            }
-        }
-        else if (property.schema.kind === 'number' || property.schema.kind === 'integer') {
-            if (property.schema.minimum !== undefined) {
-                annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.min(), [index_js_1.kt.argument.named('value', property.schema.minimum)], {
-                    target: 'get',
-                }));
-            }
-            if (property.schema.maximum !== undefined) {
-                annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.max(), [index_js_1.kt.argument.named('value', property.schema.maximum)], {
-                    target: 'get',
-                }));
-            }
-        }
-        else if (property.schema.kind === 'array') {
-            if (property.schema.minItems !== undefined || property.schema.maxItems !== undefined) {
-                annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.size(), [
-                    property.schema.minItems !== undefined ? index_js_1.kt.argument.named('min', property.schema.minItems) : null,
-                    property.schema.maxItems !== undefined ? index_js_1.kt.argument.named('max', property.schema.maxItems) : null,
-                ], { target: 'get' }));
-            }
-        }
-        if (this.shouldGenerateTypeDeclaration(ctx, { schema: property.schema })) {
-            annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.valid(), [], { target: 'field' }));
-        }
-        return annotations;
-    }
-    getSwaggerSchemaAnnotation(ctx, args) {
-        const { schema, property } = args;
-        return ctx.config.addSwaggerAnnotations
-            ? index_js_1.kt.annotation(index_js_1.kt.refs.swagger.schema(), [
-                property.schema.example !== undefined
-                    ? index_js_1.kt.argument.named('example', index_js_1.kt.string(String(property.schema.example)))
-                    : null,
-                schema.required.has(property.name) ? index_js_1.kt.argument.named('required', 'true') : null,
-                property.schema.description !== undefined
-                    ? index_js_1.kt.argument.named('description', index_js_1.kt.string(property.schema.description))
-                    : null,
-                property.schema.deprecated ? index_js_1.kt.argument.named('deprecated', index_js_1.kt.toNode(property.schema.deprecated)) : null,
-            ])
-            : null;
-    }
-    // #endregion
-    getPackageName(ctx, args) {
-        const { schema } = args;
-        const packageSuffix = typeof ctx.config.packageSuffix === 'string'
-            ? ctx.config.packageSuffix
-            : ctx.config.packageSuffix(schema);
-        return ctx.config.packageName + packageSuffix;
-    }
-    shouldGenerateTypeDeclaration(ctx, args) {
-        let { schema } = args;
-        // All enum types should have its own type declaration
-        if (schema.enum !== undefined && schema.enum.length > 0) {
-            return true;
-        }
-        // All primitive types already exist and do not need its own type declaration
-        if (schema.kind !== 'combined' &&
-            schema.kind !== 'multi-type' &&
-            schema.kind !== 'object' &&
-            schema.kind !== 'oneOf') {
-            return false;
-        }
-        // Too complex types cannot be represented in Kotlin, so they fallback to Any
-        if (schema.kind === 'multi-type') {
-            return false;
-        }
-        schema = this.normalizeSchema(ctx, { schema });
-        if (schema.kind === 'combined' || schema.kind === 'oneOf') {
-            return false;
-        }
-        // A discriminated schema is the supertype its subtypes implement and the carrier of the
-        // `@JsonTypeInfo`/`@JsonSubTypes` pair, so it always needs a declaration of its own. The two rules below
-        // simplify a schema that nothing refers to as a type; degrading a polymorphic base to `Any` or to a `Map`
-        // instead drops the supertype from every subtype and the polymorphism with it. This matters for a base
-        // whose `discriminator.propertyName` is declared on the mapping targets rather than on the base, which is
-        // legal and leaves the base with no properties of its own.
-        const isDiscriminatedBase = schema.kind === 'object' && schema.discriminator !== undefined;
-        // Schemas representable by a simple Map type do not need its own type declaration
-        if (!isDiscriminatedBase && schema.kind === 'object' && schema.properties.size === 0 && schema.additionalProperties) {
-            return false;
-        }
-        if (!isDiscriminatedBase && schema.kind === 'object' &&
-            ctx.config.emptyObjectTypeBehavior === 'use-any' && schema.properties.size === 0) {
-            return false;
-        }
-        // Dynamically generated schemas do not have its own type declaration
-        if (!ctx.data.schemas.some((x) => x.id === schema.id)) {
-            return false;
-        }
-        // multipart schemas should not have its own type declaration
-        if (schema.$src.path.endsWith('/requestBody/content/multipart/form-data/schema')) {
-            return false;
-        }
-        return true;
-    }
-    getDeclarationTypeName(ctx, args) {
-        return (0, core_1.toCasing)(args.schema.name, ctx.config.typeNameCasing);
-    }
-    getInheritedSchemas(ctx, args) {
-        return args.schema.inheritedSchemas
-            .filter((schema) => this.shouldGenerateTypeDeclaration(ctx, { schema }) && !schema.isNameGenerated)
-            .filter((item, index, self) => self.indexOf(item) === index);
-    }
-    getClassProperties(ctx, args) {
-        var _a;
-        const { schema } = args;
-        const inheritedSchemas = this.getInheritedSchemas(ctx, { schema });
-        const properties = [];
-        const appendedProperties = [];
-        for (const property of schema.properties.values()) {
-            const discriminator = (_a = inheritedSchemas.find((x) => { var _a; return ((_a = x.discriminator) === null || _a === void 0 ? void 0 : _a.propertyName) === property.name; })) === null || _a === void 0 ? void 0 : _a.discriminator;
-            if (discriminator) {
-                const schemaMappings = Object.entries(discriminator.mapping).filter(([_, v]) => v.id === schema.id);
-                if (schemaMappings.length === 1) {
-                    const p = (0, core_1.createOverwriteProxy)(property);
-                    const s = (0, core_1.createOverwriteProxy)(p.schema);
-                    p.schema = s;
-                    s.default = schemaMappings[0][0];
-                    appendedProperties.push(p);
-                    continue;
-                }
-            }
-            properties.push(property);
-        }
-        return [...this.sortProperties(ctx, { schema, properties }), ...appendedProperties];
-    }
-    sortProperties(_ctx, args) {
-        return [...args.properties].sort((a, b) => classify(a) - classify(b));
-        function classify(p) {
-            if (p.schema.default !== undefined)
-                return 1;
-            if (args.schema.required.has(p.name))
-                return 0;
-            return 2;
-        }
-    }
-    normalizeSchema(ctx, args) {
-        let { schema } = args;
-        schema = this.normalizeDiscriminatedBases(ctx, { schema });
-        if (schema.kind === 'oneOf') {
-            schema = ctx.config.oneOfBehavior === 'treat-as-any-of'
-                // deno-lint-ignore no-explicit-any
-                ? { ...schema, kind: 'combined', anyOf: schema.oneOf, allOf: [], oneOf: undefined }
-                // deno-lint-ignore no-explicit-any
-                : { ...schema, kind: 'combined', allOf: schema.oneOf, anyOf: [], oneOf: undefined };
-            ctx.schema = schema;
-        }
-        if (schema.kind === 'object' || schema.kind === 'combined') {
-            const mergedSchema = (0, core_1.resolveAnyOfAndAllOf)(schema, true);
-            if (mergedSchema) {
-                schema = mergedSchema;
-            }
-        }
-        return schema;
-    }
-    /**
-     * Rewrites every discriminated `oneOf` base reachable from the schema through a composition into the
-     * `object` it describes, so that the merge in `normalizeSchema` treats it as one.
-     *
-     * A schema that declares a `oneOf` is of kind `oneOf` even when it also declares `type: object` and
-     * properties of its own — `determineSchemaKind` looks at `oneOf` first. For a *discriminated* `oneOf` that
-     * loses the very information the Kotlin declarations need, because the branches of such a `oneOf` are the
-     * schema's subtypes rather than parts of it (the same distinction `resolveAnyOfAndAllOf` draws for a `oneOf`
-     * nested inside a composition):
-     *
-     * - the base is an object in its own right, described by its own `properties`, `required` and any
-     *   `allOf`/`anyOf` it composes — so its interface must declare those and nothing else, not the union of
-     *   what its subtypes declare;
-     * - a subtype's `allOf: [Base]` is a composition with that object — so the subtype must inherit the base's
-     *   own properties, including the discriminator, while inheriting nothing from its siblings.
-     *
-     * Both follow from turning the base into an `object` before the merge runs: the merge already collects the
-     * properties of an `object` branch and already declines to collect the branches of a discriminated `oneOf`.
-     * This is why `AllOfInheritanceDiscriminator` in test/specs/v3/discriminator-variants.yml has always been
-     * correct — with no `oneOf` keyword it is of kind `object` already — while every `oneOf`-holder base in the
-     * same document was not.
-     */
-    normalizeDiscriminatedBases(_ctx, args) {
-        // `normalizeSchema` runs once per property type via `shouldGenerateTypeDeclaration`, and almost no schema
-        // has a discriminated base anywhere below it. Answering that first costs one traversal and one set, and
-        // lets the overwhelmingly common case return the schema itself rather than a copy per composing schema.
-        //
-        // The question is asked once for the whole call rather than again per branch: a per-branch answer would
-        // have to be memoised to stay linear, and memoising it is unsound, because a walk truncated by the cycle
-        // guard can record `false` for a branch that reaches a base only by going back through an ancestor.
-        if (!containsDiscriminatedBase(args.schema, new Set()))
-            return args.schema;
-        const rewritten = new Map();
-        return rewrite(args.schema);
-        function rewrite(schema) {
-            const existing = rewritten.get(schema);
-            if (existing)
-                return existing;
-            const isBase = isDiscriminatedBase(schema);
-            const allOf = branches(schema, 'allOf');
-            const anyOf = branches(schema, 'anyOf');
-            // The branches of a discriminated `oneOf` are dropped rather than descended into: they are the schema's
-            // subtypes, and a subtype is generated from its own file where it is the root of this walk.
-            const oneOf = isBase ? [] : branches(schema, 'oneOf');
-            if (!isBase && allOf.length === 0 && anyOf.length === 0 && oneOf.length === 0) {
-                return schema;
-            }
-            // Registered before descending, so a branch composing back to one of its own ancestors terminates.
-            // deno-lint-ignore no-explicit-any
-            const copy = { ...schema };
-            rewritten.set(schema, copy);
-            if (isBase) {
-                copy.kind = 'object';
-                copy.type = 'object';
-            }
-            copy.allOf = allOf.map(rewrite);
-            copy.anyOf = anyOf.map(rewrite);
-            copy.oneOf = oneOf.map(rewrite);
-            return copy;
-        }
-        /** Whether the schema or anything it composes is a base this walk would rewrite. */
-        function containsDiscriminatedBase(schema, visited) {
-            if (visited.has(schema))
-                return false;
-            visited.add(schema);
-            if (isDiscriminatedBase(schema))
-                return true;
-            const contains = (x) => containsDiscriminatedBase(x, visited);
-            return branches(schema, 'allOf').some(contains) ||
-                branches(schema, 'anyOf').some(contains) ||
-                branches(schema, 'oneOf').some(contains);
-        }
-        function isDiscriminatedBase(schema) {
-            return schema.kind === 'oneOf' && schema.discriminator !== undefined;
-        }
-        /**
-         * The branches a schema composes under one keyword. `normalizeSchema` leaves an explicit
-         * `oneOf: undefined` behind when it rewrites a `oneOf` holder, so a keyword can be present with no value.
-         */
-        function branches(schema, keyword) {
-            var _a;
-            const values = schema;
-            return (_a = values[keyword]) !== null && _a !== void 0 ? _a : [];
-        }
-    }
-    hasProperty(ctx, args) {
-        // A composition branch may compose back to one of its own ancestors (see test/specs/v3/anyof-cycle.yml).
-        // Without this guard such a cycle recurses until the stack overflows. Re-visiting a schema can never
-        // change the answer, so returning `false` for one is safe: another path either already found the
-        // property or does not contain it at all.
-        const { schema, propertyName, visited = new Set() } = args;
-        if (visited.has(schema))
-            return false;
-        visited.add(schema);
-        return (('properties' in schema && schema.properties.has(propertyName)) ||
-            ('anyOf' in schema && schema.anyOf.some((schema) => this.hasProperty(ctx, { schema, propertyName, visited }))) ||
-            ('allOf' in schema && schema.allOf.some((schema) => this.hasProperty(ctx, { schema, propertyName, visited }))) ||
-            // Only an undiscriminated `oneOf` composes into the schema that references it, matching which `oneOf`
-            // branches `resolveAnyOfAndAllOf` merges. A discriminated one lists subtypes, whose properties are not
-            // the referencing schema's, so an inherited property never comes from there.
-            ('oneOf' in schema && !schema.discriminator &&
-                schema.oneOf.some((schema) => this.hasProperty(ctx, { schema, propertyName, visited }))));
-    }
-}
-exports.DefaultKotlinModelGenerator = DefaultKotlinModelGenerator;

package/script/src/generators/models/models-generator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"models-generator.d.ts","sourceRoot":"","sources":["../../../../src/src/generators/models/models-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EACd,OAAO,EACP,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC5B,oCAAoC,EACrC,MAAM,aAAa,CAAC;AAErB,OAAO,EAA+B,KAAK,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAC9F,OAAO,EAEL,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EAChC,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAC/B,KAAK,2BAA2B,EACjC,MAAM,aAAa,CAAC;AAErB,KAAK,KAAK,GAAG,0BAA0B,CAAC;AACxC,KAAK,MAAM,GAAG,2BAA2B,CAAC;AAC1C,KAAK,MAAM,GAAG,2BAA2B,CAAC;AAC1C,KAAK,YAAY,GAAG,0BAA0B,CAAC;AAC/C,KAAK,OAAO,GAAG,4BAA4B,CAAC;AAE5C,qBAAa,qBAAsB,SAAQ,oCAAoC,CAC7E,KAAK,EACL,MAAM,EACN,MAAM,EACN,YAAY,EACZ,OAAO,CACR;IACC,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAAoC;gBAE/D,qBAAqB,CAAC,EAAE,OAAO,CAAC,oBAAoB,EAAE,EAAE,CAAC;cAKlD,UAAU,IAAI,MAAM;cAQpB,YAAY,CAC7B,OAAO,EAAE,uBAAuB,CAAC,0BAA0B,CAAC,EAC5D,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,SAAS,GACnC,OAAO;cAIS,cAAc,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAG,YAAY,CAAC,YAAY,CAAC;cAQ3E,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI;CAGhG"}