@goast/kotlin 0.6.0 → 0.7.0-beta.1

package/script/src/generators/services/spring-controllers/spring-controller-generator.js

@@ -1,700 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultKotlinSpringControllerGenerator = void 0;
-exports.adjustListType = adjustListType;
-const core_1 = require("@goast/core");
-const http_status_codes_1 = require("http-status-codes");
-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");
-const strictResponseCustomProperty = 'strict-response';
-class DefaultKotlinSpringControllerGenerator extends file_generator_js_1.KotlinFileGenerator {
-    generate(ctx) {
-        const packageName = this.getPackageName(ctx, {});
-        const dirPath = this.getDirectoryPath(ctx, { packageName });
-        console.log(`Generating service ${ctx.service.id} to ${dirPath}...`);
-        console.log(`  Endpoints:`);
-        ctx.service.endpoints.forEach((endpoint) => {
-            console.log(`  - ${(0, core_1.getSourceDisplayName)(ctx.data, endpoint)} [${(0, core_1.toCasing)(endpoint.name, ctx.config.functionNameCasing)}]`);
-        });
-        return {
-            apiInterface: this.generateApiInterfaceFile(ctx, {
-                dirPath,
-                packageName,
-            }),
-            apiController: this.generateApiControllerFile(ctx, {
-                dirPath,
-                packageName,
-            }),
-            apiDelegate: this.generateApiDelegateInterfaceFile(ctx, {
-                dirPath,
-                packageName,
-            }),
-        };
-    }
-    // #region API Interface
-    generateApiInterfaceFile(ctx, args) {
-        const { dirPath, packageName } = args;
-        const typeName = this.getApiInterfaceName(ctx, {});
-        const fileName = `${typeName}.kt`;
-        const filePath = `${dirPath}/${fileName}`;
-        console.log(`  Generating API interface ${typeName} to ${fileName}...`);
-        const builder = new file_builder_js_1.KotlinFileBuilder(packageName, ctx.config);
-        builder.append(this.getApiInterfaceFileContent(ctx, { interfaceName: typeName }));
-        builder.writeToFile(filePath);
-        return { typeName, packageName };
-    }
-    getApiInterfaceFileContent(ctx, args) {
-        const { interfaceName } = args;
-        return (0, core_1.appendValueGroup)([this.getApiInterface(ctx, { interfaceName })], '\n');
-    }
-    getApiInterface(ctx, args) {
-        const { interfaceName } = args;
-        return index_js_1.kt.interface(interfaceName, {
-            annotations: this.getApiInterfaceAnnotations(ctx),
-            members: this.getApiInterfaceMembers(ctx),
-            companionObject: index_js_1.kt.object({
-                members: ctx.service.endpoints.map((endpoint) => index_js_1.kt.property(this.getPathConstantName(ctx, { endpoint }), {
-                    const: true,
-                    default: index_js_1.kt.string(this.getEndpointPath(ctx, { endpoint })),
-                })),
-            }),
-        });
-    }
-    getApiInterfaceAnnotations(ctx) {
-        const validated = index_js_1.kt.annotation(index_js_1.kt.refs.spring.validated());
-        const requestMapping = index_js_1.kt.annotation(index_js_1.kt.refs.spring.requestMapping(), [
-            index_js_1.kt.argument(this.getControllerRequestMapping(ctx, { prefix: 'api' })),
-        ]);
-        return [validated, requestMapping];
-    }
-    getApiInterfaceMembers(ctx) {
-        const members = [];
-        const delegateInterfaceName = this.getApiDelegateInterfaceName(ctx, {});
-        members.push(index_js_1.kt.function('getDelegate', {
-            returnType: delegateInterfaceName,
-            singleExpression: true,
-            body: index_js_1.kt.object({
-                implements: [delegateInterfaceName],
-            }),
-        }), index_js_1.kt.function('getExceptionHandler', {
-            returnType: ctx.refs.apiExceptionHandler({ nullable: true }),
-            singleExpression: true,
-            body: index_js_1.kt.toNode(null),
-        }));
-        ctx.service.endpoints.forEach((endpoint) => {
-            members.push(this.getApiInterfaceEndpointMethod(ctx, { endpoint }));
-        });
-        members.push(...ctx.service.endpoints
-            .filter((endpoint) => { var _a; return (_a = endpoint.custom[strictResponseCustomProperty]) !== null && _a !== void 0 ? _a : ctx.config.strictResponseEntities; })
-            .map((endpoint) => this.getApiResponseEntityClass(ctx, { endpoint })));
-        return members;
-    }
-    getApiInterfaceEndpointMethod(ctx, args) {
-        const { endpoint } = args;
-        const parameters = this.getAllParameters(ctx, { endpoint });
-        return index_js_1.kt.function((0, core_1.toCasing)(endpoint.name, ctx.config.functionNameCasing), {
-            doc: index_js_1.kt.doc(this.getEndpointDocDescription(ctx, { endpoint })),
-            suspend: ctx.config.suspendingFunctions,
-            annotations: this.getApiInterfaceEndpointMethodAnnnotations(ctx, endpoint),
-            parameters: parameters.map((parameter) => this.getApiInterfaceEndpointMethodParameter(ctx, endpoint, parameter)),
-            returnType: index_js_1.kt.refs.spring.responseEntity(['*']),
-            body: this.getApiInterfaceEndpointMethodBody(ctx, endpoint, parameters),
-        });
-    }
-    getApiInterfaceEndpointMethodAnnnotations(ctx, endpoint) {
-        var _a, _b, _c;
-        const annotations = [];
-        if (ctx.config.addSwaggerAnnotations) {
-            annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.swagger.operation(), [
-                endpoint.summary ? index_js_1.kt.argument.named('summary', index_js_1.kt.string((_a = endpoint.summary) === null || _a === void 0 ? void 0 : _a.trim())) : null,
-                index_js_1.kt.argument.named('operationId', index_js_1.kt.string(endpoint.name)),
-                endpoint.description
-                    ? index_js_1.kt.argument.named('description', index_js_1.kt.string((_b = endpoint.description) === null || _b === void 0 ? void 0 : _b.trim()))
-                    : null,
-                endpoint.deprecated !== undefined ? index_js_1.kt.argument.named('deprecated', index_js_1.kt.toNode(endpoint.deprecated)) : null,
-            ]));
-            if (endpoint.responses.length > 0) {
-                annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.swagger.apiResponses(), [
-                    index_js_1.kt.argument.named('value', index_js_1.kt.collectionLiteral(endpoint.responses.map((response) => {
-                        var _a;
-                        return index_js_1.kt.call(index_js_1.kt.refs.swagger.apiResponse(), [
-                            index_js_1.kt.argument.named('responseCode', 
-                            // The spec's own response key, not `statusCode`: that field is `undefined` for
-                            // `default` and every range code, and `kt.string(undefined)` renders the bare token
-                            // `null`, which is not assignable to this non-nullable annotation element.
-                            index_js_1.kt.string(response.statusKey)),
-                            response.description
-                                ? index_js_1.kt.argument.named('description', index_js_1.kt.string((_a = response.description) === null || _a === void 0 ? void 0 : _a.trim()))
-                                : null,
-                            index_js_1.kt.argument.named('content', index_js_1.kt.collectionLiteral((response.contentOptions.length === 0
-                                ? [{ schema: undefined, type: undefined }]
-                                : response.contentOptions).map((content) => {
-                                var _a;
-                                let schemaType = (_a = this.getSchemaType(ctx, {
-                                    schema: content.schema,
-                                })) !== null && _a !== void 0 ? _a : index_js_1.kt.refs.any();
-                                let isArray = false;
-                                if (index_js_1.kt.refs.list.matches(schemaType)) {
-                                    isArray = true;
-                                    schemaType = schemaType.generics[0];
-                                }
-                                let ktSchema = index_js_1.kt.call(index_js_1.kt.refs.swagger.schema(), [
-                                    index_js_1.kt.argument.named('implementation', (0, core_1.builderTemplate) `${schemaType}::class`),
-                                ]);
-                                if (isArray) {
-                                    ktSchema = index_js_1.kt.call(index_js_1.kt.refs.swagger.arraySchema(), [
-                                        index_js_1.kt.argument.named('schema', ktSchema),
-                                    ]);
-                                }
-                                return index_js_1.kt.call(index_js_1.kt.refs.swagger.content(), [
-                                    content.type
-                                        ? index_js_1.kt.argument.named('mediaType', index_js_1.kt.string(content.type))
-                                        : null,
-                                    content.schema
-                                        ? index_js_1.kt.argument.named(isArray ? 'array' : 'schema', ktSchema)
-                                        : null,
-                                ]);
-                            }))),
-                        ]);
-                    }))),
-                ]));
-            }
-        }
-        const requestMapping = index_js_1.kt.annotation(index_js_1.kt.refs.spring.requestMapping(), [
-            index_js_1.kt.argument.named('method', index_js_1.kt.collectionLiteral([
-                index_js_1.kt.call([
-                    index_js_1.kt.refs.spring.requestMethod(),
-                    endpoint.method.toUpperCase(),
-                ]),
-            ])),
-            index_js_1.kt.argument.named('value', index_js_1.kt.collectionLiteral([this.getPathConstantName(ctx, { endpoint })])),
-        ]);
-        if (endpoint.requestBody && endpoint.requestBody.content.length > 0) {
-            requestMapping.arguments.push(index_js_1.kt.argument.named('consumes', index_js_1.kt.collectionLiteral((_c = endpoint.requestBody) === null || _c === void 0 ? void 0 : _c.content.map((x) => index_js_1.kt.string(x.type)))));
-        }
-        annotations.push(requestMapping);
-        return annotations;
-    }
-    getApiInterfaceEndpointMethodParameter(ctx, endpoint, parameter) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        const enumItemSchema = parameter.multipart ? undefined : (0, utils_js_1.getArrayItemStringEnumSchema)(parameter.schema);
-        const enumSchema = parameter.multipart ? undefined : (0, utils_js_1.getStringEnumSchema)(parameter.schema);
-        const enumValueSchema = enumSchema !== null && enumSchema !== void 0 ? enumSchema : enumItemSchema;
-        const actualType = this.getSchemaType(ctx, { schema: parameter.schema });
-        const isEnumSchema = !!enumValueSchema && !!actualType &&
-            !!this.getSchemaType(ctx, { schema: enumValueSchema });
-        const schemaType = !isEnumSchema
-            ? actualType
-            : enumItemSchema
-                ? index_js_1.kt.refs.list([index_js_1.kt.refs.string()], { nullable: actualType === null || actualType === void 0 ? void 0 : actualType.nullable })
-                : index_js_1.kt.refs.string({ nullable: actualType === null || actualType === void 0 ? void 0 : actualType.nullable });
-        const result = index_js_1.kt.parameter((0, core_1.toCasing)(parameter.name, ctx.config.parameterNameCasing), this.getParameterType(ctx, {
-            endpoint,
-            parameter,
-            type: isEnumSchema ? schemaType : undefined,
-        }), {
-            default: parameter.multipart && ((_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.default) !== undefined
-                ? index_js_1.kt.toNode((_b = parameter.schema) === null || _b === void 0 ? void 0 : _b.default)
-                : null,
-        });
-        if (ctx.config.addSwaggerAnnotations) {
-            const annotation = index_js_1.kt.annotation(index_js_1.kt.refs.swagger.parameter(), [
-                parameter.multipart ? index_js_1.kt.argument.named('name', index_js_1.kt.string(parameter.multipart.name)) : null,
-                parameter.description
-                    ? index_js_1.kt.argument.named('description', index_js_1.kt.string((_c = parameter.description) === null || _c === void 0 ? void 0 : _c.trim()))
-                    : null,
-                index_js_1.kt.argument.named('required', parameter.required),
-                // Only emitted when set, matching how the model generator marks a deprecated property on `@Schema`.
-                // `@Operation` always states `deprecated`, but doing that for every parameter of every endpoint
-                // would add `deprecated = false` noise far beyond what the annotation is documenting.
-                parameter.deprecated ? index_js_1.kt.argument.named('deprecated', index_js_1.kt.toNode(true)) : null,
-                parameter.target === 'header' ? index_js_1.kt.argument.named('hidden', index_js_1.kt.toNode(true)) : null,
-            ]);
-            const schemaArgs = [];
-            if (((_d = parameter.schema) === null || _d === void 0 ? void 0 : _d.default) !== undefined) {
-                schemaArgs.push(index_js_1.kt.argument.named('defaultValue', index_js_1.kt.string(String((_e = parameter.schema) === null || _e === void 0 ? void 0 : _e.default))));
-            }
-            if (isEnumSchema) {
-                schemaArgs.push(index_js_1.kt.argument.named('allowableValues', index_js_1.kt.collectionLiteral((_f = enumValueSchema === null || enumValueSchema === void 0 ? void 0 : enumValueSchema.enum) === null || _f === void 0 ? void 0 : _f.map((x) => index_js_1.kt.string(x === null || x === void 0 ? void 0 : x.toString())))));
-            }
-            if (schemaArgs.length) {
-                annotation.arguments.push(index_js_1.kt.argument.named('schema', index_js_1.kt.call([index_js_1.kt.refs.swagger.schema()], schemaArgs)));
-            }
-            result.annotations.push(annotation);
-        }
-        const isCorePackage = !(schemaType === null || schemaType === void 0 ? void 0 : schemaType.packageName) ||
-            /^(kotlin|java)(\..*|$)/.test(schemaType.packageName);
-        if (!isCorePackage && ctx.config.addJakartaValidationAnnotations) {
-            result.annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.valid()));
-        }
-        if (parameter.target === 'body' && !parameter.multipart) {
-            // A bare @RequestBody is required as far as Spring is concerned, so an optional body has to say so in the
-            // annotation too - the nullable parameter type alone still answers 400 when the body is missing.
-            result.annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.spring.requestBody(), parameter.required ? [] : [index_js_1.kt.argument.named('required', parameter.required)]));
-        }
-        if (parameter.target === 'query') {
-            const annotation = index_js_1.kt.annotation(index_js_1.kt.refs.spring.requestParam(), [
-                index_js_1.kt.argument.named('value', index_js_1.kt.string(parameter.name)),
-                index_js_1.kt.argument.named('required', parameter.required),
-            ]);
-            if (((_g = parameter.schema) === null || _g === void 0 ? void 0 : _g.default) !== undefined) {
-                annotation.arguments.push(index_js_1.kt.argument.named('defaultValue', index_js_1.kt.string(String((_h = parameter.schema) === null || _h === void 0 ? void 0 : _h.default))));
-            }
-            result.annotations.push(annotation);
-        }
-        if (parameter.target === 'path') {
-            result.annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.spring.pathVariable(), [
-                index_js_1.kt.string(parameter.name),
-            ]));
-        }
-        if (parameter.target === 'header') {
-            result.annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.spring.requestHeader(), [
-                index_js_1.kt.string(parameter.name),
-            ]));
-        }
-        if (parameter.multipart) {
-            result.annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.spring.requestPart(), [
-                index_js_1.kt.argument.named('value', index_js_1.kt.string(parameter.multipart.name)),
-                index_js_1.kt.argument.named('required', parameter.required),
-            ]));
-        }
-        return result;
-    }
-    getApiInterfaceEndpointMethodBody(ctx, endpoint, parameters) {
-        const body = (0, core_1.appendValueGroup)([], '\n');
-        parameters.forEach((x) => {
-            var _a, _b;
-            const paramName = (0, core_1.toCasing)(x.name, ctx.config.parameterNameCasing);
-            if (x.multipart)
-                return;
-            const enumItemSchema = (0, utils_js_1.getArrayItemStringEnumSchema)(x.schema);
-            const enumValueSchema = (_a = (0, utils_js_1.getStringEnumSchema)(x.schema)) !== null && _a !== void 0 ? _a : enumItemSchema;
-            if (!enumValueSchema)
-                return;
-            const schemaType = this.getSchemaType(ctx, { schema: x.schema });
-            const enumType = this.getSchemaType(ctx, { schema: enumValueSchema });
-            if (schemaType && enumType) {
-                body.values.push((0, core_1.builderTemplate) `val ${paramName} = ${paramName}${schemaType.nullable || (!x.required && !((_b = x.schema) === null || _b === void 0 ? void 0 : _b.default)) ? '?' : ''}.${enumItemSchema ? 'map' : 'let'} { ${enumType}.fromValue(it) ?: return ${index_js_1.kt.refs.spring.responseEntity.infer()}.status(${index_js_1.kt.refs.spring.httpStatus()}.BAD_REQUEST).body(${index_js_1.kt.string(`Invalid value for parameter ${x.name}`)}) }`);
-            }
-        });
-        body.values.push((0, core_1.builderTemplate) `try {${core_1.builderTemplate.indent `
-          return ${index_js_1.kt.call([
-            index_js_1.kt.call(index_js_1.kt.reference('getDelegate'), []),
-            (0, core_1.toCasing)(endpoint.name, ctx.config.functionNameCasing),
-        ], parameters.map((x) => (0, core_1.toCasing)(x.name, ctx.config.parameterNameCasing)))}`}
-        } catch (e: ${index_js_1.kt.refs.throwable()}) {${core_1.builderTemplate.indent `
-          return getExceptionHandler()?.handleApiException(e) ?: throw e`}
-        }`);
-        return body;
-    }
-    getApiResponseEntityClass(ctx, args) {
-        const { endpoint } = args;
-        const name = this.getApiResponseEntityName(ctx, { endpoint });
-        // Spring 7's `ResponseEntity<T>` carries an `Any` upper bound (JSpecify), so the subclass must bound `T`.
-        // The body parameter is then made nullable (`T?`) to keep null-body ("no response body") responses legal
-        // while staying wire-identical, since Spring's super constructor accepts a `@Nullable T body`.
-        const springBoot4 = ctx.config.springBootVersion === 4;
-        return index_js_1.kt.class(name, {
-            doc: index_js_1.kt.doc(`Response entity for ${endpoint.name}.`),
-            generics: [index_js_1.kt.genericParameter('T', springBoot4 ? { constraint: index_js_1.kt.refs.any() } : undefined)],
-            primaryConstructor: index_js_1.kt.constructor([
-                index_js_1.kt.parameter.class('body', index_js_1.kt.reference('T', null, springBoot4 ? { nullable: true } : undefined)),
-                index_js_1.kt.parameter.class('rawStatus', index_js_1.kt.refs.int()),
-                index_js_1.kt.parameter.class('headers', index_js_1.kt.refs.spring.multiValueMap([index_js_1.kt.refs.string(), index_js_1.kt.refs.string()], {
-                    nullable: true,
-                }), { default: index_js_1.kt.toNode(null) }),
-            ], null, {
-                accessModifier: endpoint.responses.length > 0 ? 'private' : null,
-                delegateTarget: 'super',
-                delegateArguments: [
-                    index_js_1.kt.argument('body'),
-                    index_js_1.kt.argument('headers'),
-                    index_js_1.kt.argument('rawStatus'),
-                ],
-            }),
-            extends: index_js_1.kt.refs.spring.responseEntity([index_js_1.kt.reference('T')]),
-            companionObject: index_js_1.kt.object({
-                members: Array.from(new Set([
-                    ...ctx.config.defaultStatusCodes,
-                    501,
-                    ...endpoint.responses.map((x) => x.statusCode),
-                ].filter(core_1.notNullish))).map((code) => {
-                    var _a;
-                    const fnName = (0, core_1.toCasing)((0, http_status_codes_1.getReasonPhrase)(code), ctx.config.functionNameCasing);
-                    const response = endpoint.responses.find((x) => x.statusCode === code);
-                    const responseType = response ? this.getResponseType(ctx, { endpoint, response }) : undefined;
-                    const contentType = (_a = response === null || response === void 0 ? void 0 : response.contentOptions.find((x) => x.schema)) === null || _a === void 0 ? void 0 : _a.type;
-                    const hasResponseBody = responseType && !index_js_1.kt.refs.unit.matches(responseType);
-                    return index_js_1.kt.function(fnName, {
-                        parameters: [
-                            hasResponseBody ? index_js_1.kt.parameter.class('body', responseType) : null,
-                            index_js_1.kt.parameter.class('headers', index_js_1.kt.refs.spring.multiValueMap([index_js_1.kt.refs.string(), index_js_1.kt.refs.string()], { nullable: true }), { default: index_js_1.kt.toNode(null) }),
-                        ],
-                        singleExpression: true,
-                        body: index_js_1.kt.call([
-                            index_js_1.kt.reference(this.getApiResponseEntityName(ctx, { endpoint }), null, {
-                                generics: [
-                                    hasResponseBody
-                                        ? responseType
-                                        // `Unit?` violates the `T : Any` bound under Spring Boot 4; the `null` body argument
-                                        // below stays (now legal because the subclass body parameter is nullable).
-                                        : (springBoot4 ? index_js_1.kt.refs.unit() : index_js_1.kt.refs.unit({ nullable: true })),
-                                ],
-                            }),
-                        ], [
-                            hasResponseBody ? index_js_1.kt.argument('body') : index_js_1.kt.toNode(null),
-                            index_js_1.kt.toNode(code),
-                            contentType
-                                ? (0, core_1.builderTemplate) `${index_js_1.kt.refs.spring.linkedMultiValueMap([index_js_1.kt.refs.string(), index_js_1.kt.refs.string()])}().also {
-                        if (headers != null) {
-                            it.putAll(headers)
-                        }
-                        it.addIfAbsent("Content-Type", ${index_js_1.kt.string(contentType)})
-                    }`
-                                : index_js_1.kt.argument('headers'),
-                        ]),
-                    });
-                }),
-            }),
-        });
-    }
-    // #endregion
-    // #region API Controller
-    generateApiControllerFile(ctx, args) {
-        const { dirPath, packageName } = args;
-        const typeName = this.getApiControllerName(ctx, {});
-        const fileName = `${typeName}.kt`;
-        const filePath = `${dirPath}/${fileName}`;
-        console.log(`  Generating API controller ${typeName} to ${fileName}...`);
-        const builder = new file_builder_js_1.KotlinFileBuilder(packageName, ctx.config);
-        builder.append(this.getApiControllerFileContent(ctx, { controllerName: typeName }));
-        builder.writeToFile(filePath);
-        return { typeName, packageName };
-    }
-    getApiControllerFileContent(ctx, args) {
-        const { controllerName } = args;
-        return (0, core_1.appendValueGroup)([this.getApiController(ctx, { controllerName })], '\n');
-    }
-    getApiController(ctx, args) {
-        const { controllerName } = args;
-        return index_js_1.kt.class(controllerName, {
-            annotations: this.getApiControllerAnnotations(ctx),
-            primaryConstructor: index_js_1.kt.constructor([
-                index_js_1.kt.parameter.class('delegate', index_js_1.kt.reference(this.getApiDelegateInterfaceName(ctx, {}), null, {
-                    nullable: true,
-                }), {
-                    annotations: [
-                        index_js_1.kt.annotation(index_js_1.kt.refs.spring.autowired(), [
-                            index_js_1.kt.argument.named('required', 'false'),
-                        ]),
-                    ],
-                }),
-                index_js_1.kt.parameter.class('exceptionHandler', ctx.refs.apiExceptionHandler({ nullable: true }), {
-                    annotations: [
-                        index_js_1.kt.annotation(index_js_1.kt.refs.spring.autowired(), [
-                            index_js_1.kt.argument.named('required', 'false'),
-                        ]),
-                    ],
-                    accessModifier: 'private',
-                    property: 'readonly',
-                }),
-            ]),
-            implements: [this.getApiInterfaceName(ctx, {})],
-            members: this.getApiControllerMembers(ctx),
-        });
-    }
-    getApiControllerAnnotations(ctx) {
-        const annotations = [];
-        if (ctx.config.addJakartaValidationAnnotations) {
-            annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.generated(), [
-                index_js_1.kt.argument.named('value', index_js_1.kt.collectionLiteral([
-                    index_js_1.kt.string('com.goast.kotlin.spring-service-generator'),
-                ])),
-            ]));
-        }
-        annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.spring.controller()));
-        annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.spring.requestMapping(), [
-            this.getControllerRequestMapping(ctx, {}),
-        ]));
-        return annotations;
-    }
-    getApiControllerMembers(ctx) {
-        const delegateInterfaceName = this.getApiDelegateInterfaceName(ctx, {});
-        const delegateProp = index_js_1.kt.property('delegate', {
-            accessModifier: 'private',
-            default: (0, core_1.builderTemplate) `delegate ?: ${index_js_1.kt.object({ implements: [delegateInterfaceName] })}`,
-        });
-        const getDelegateFun = index_js_1.kt.function('getDelegate', {
-            override: true,
-            returnType: delegateInterfaceName,
-            singleExpression: true,
-            body: index_js_1.kt.reference('delegate'),
-        });
-        const getExceptionHandlerFun = index_js_1.kt.function('getExceptionHandler', {
-            override: true,
-            returnType: ctx.refs.apiExceptionHandler({ nullable: true }),
-            singleExpression: true,
-            body: index_js_1.kt.reference('exceptionHandler'),
-        });
-        return [delegateProp, getDelegateFun, getExceptionHandlerFun];
-    }
-    // #endregion
-    // #region API Delegate Interface
-    generateApiDelegateInterfaceFile(ctx, args) {
-        const { dirPath, packageName } = args;
-        const typeName = this.getApiDelegateInterfaceName(ctx, {});
-        const fileName = `${typeName}.kt`;
-        const filePath = `${dirPath}/${fileName}`;
-        console.log(`  Generating API delegate ${typeName} to ${fileName}...`);
-        const builder = new file_builder_js_1.KotlinFileBuilder(packageName, ctx.config);
-        builder.append(this.getApiDelegateInterfaceFileContent(ctx, {
-            delegateInterfaceName: typeName,
-        }));
-        builder.writeToFile(filePath);
-        return { typeName, packageName };
-    }
-    getApiDelegateInterfaceFileContent(ctx, args) {
-        const { delegateInterfaceName } = args;
-        return (0, core_1.appendValueGroup)([this.getApiDelegateInterface(ctx, { delegateInterfaceName })], '\n');
-    }
-    getApiDelegateInterface(ctx, args) {
-        const { delegateInterfaceName } = args;
-        return index_js_1.kt.interface(delegateInterfaceName, {
-            annotations: this.getApiDelegateInterfaceAnnotations(ctx),
-            members: this.getApiDelegateInterfaceMembers(ctx),
-        });
-    }
-    getApiDelegateInterfaceAnnotations(ctx) {
-        const annotations = [];
-        if (ctx.config.addJakartaValidationAnnotations) {
-            annotations.push(index_js_1.kt.annotation(index_js_1.kt.refs.jakarta.generated(), [
-                index_js_1.kt.argument.named('value', index_js_1.kt.collectionLiteral([
-                    index_js_1.kt.string('com.goast.kotlin.spring-service-generator'),
-                ])),
-            ]));
-        }
-        return annotations;
-    }
-    getApiDelegateInterfaceMembers(ctx) {
-        const members = [];
-        members.push(index_js_1.kt.function('getRequest', {
-            returnType: index_js_1.kt.refs.java.optional([index_js_1.kt.refs.spring.nativeWebRequest()]),
-            singleExpression: true,
-            body: index_js_1.kt.call([index_js_1.kt.refs.java.optional.infer(), 'empty'], []),
-        }));
-        ctx.service.endpoints.forEach((endpoint) => {
-            members.push(this.getApiDelegateInterfaceEndpointMethod(ctx, { endpoint }));
-        });
-        return members;
-    }
-    getApiDelegateInterfaceEndpointMethod(ctx, args) {
-        var _a;
-        const { endpoint } = args;
-        const parameters = this.getAllParameters(ctx, { endpoint });
-        const fn = index_js_1.kt.function((0, core_1.toCasing)(endpoint.name, ctx.config.functionNameCasing), {
-            doc: index_js_1.kt.doc(this.getEndpointDocDescription(ctx, { endpoint })),
-            suspend: ctx.config.suspendingFunctions,
-            parameters: parameters.map((parameter) => {
-                return index_js_1.kt.parameter((0, core_1.toCasing)(parameter.name, ctx.config.parameterNameCasing), this.getParameterType(ctx, { endpoint, parameter }));
-            }),
-        });
-        if ((_a = endpoint.custom[strictResponseCustomProperty]) !== null && _a !== void 0 ? _a : ctx.config.strictResponseEntities) {
-            const responseEntity = index_js_1.kt.reference.genericFactory(this.getApiResponseEntityName(ctx, { endpoint }), `${this.getPackageName(ctx, {})}.${this.getApiInterfaceName(ctx, {})}`);
-            fn.returnType = responseEntity(['*']);
-            fn.body = (0, core_1.appendValueGroup)([
-                (0, core_1.builderTemplate) `return ${index_js_1.kt.call([
-                    responseEntity.infer(),
-                    (0, core_1.toCasing)((0, http_status_codes_1.getReasonPhrase)(501), ctx.config.functionNameCasing),
-                ], [])}`,
-            ], '\n');
-        }
-        else {
-            fn.returnType = index_js_1.kt.refs.spring.responseEntity([
-                this.getResponseType(ctx, { endpoint }),
-            ]);
-            fn.body = (0, core_1.appendValueGroup)([
-                (0, core_1.builderTemplate) `return ${index_js_1.kt.refs.spring.responseEntity.infer()}(${index_js_1.kt.refs.spring.httpStatus()}.NOT_IMPLEMENTED)`,
-            ], '\n');
-        }
-        return fn;
-    }
-    // #endregion
-    getParameterType(ctx, args) {
-        var _a, _b;
-        const { parameter } = args;
-        if ((_a = parameter.multipart) === null || _a === void 0 ? void 0 : _a.isFile) {
-            return index_js_1.kt.refs.spring.filePart();
-        }
-        const type = this.getTypeUsage(ctx, {
-            schema: parameter.schema,
-            nullable: (!parameter.required && ((_b = parameter.schema) === null || _b === void 0 ? void 0 : _b.default) === undefined) ||
-                undefined,
-            type: args.type,
-        });
-        return parameter.target === 'body' ? adjustListType(ctx, type) : type;
-    }
-    getResponseType(ctx, args) {
-        const { endpoint, response } = args;
-        const responseSchemas = (response ? [response] : endpoint.responses)
-            .flatMap((x) => x.contentOptions.flatMap((x) => x.schema))
-            .filter(core_1.notNullish)
-            .filter((x, i, a) => a.findIndex((y) => {
-            const xType = this.getSchemaType(ctx, { schema: x });
-            const yType = this.getSchemaType(ctx, { schema: y });
-            return ((xType === null || xType === void 0 ? void 0 : xType.name) === (yType === null || yType === void 0 ? void 0 : yType.name) &&
-                (xType === null || xType === void 0 ? void 0 : xType.packageName) === (yType === null || yType === void 0 ? void 0 : yType.packageName));
-        }) === i);
-        if (responseSchemas.length === 1) {
-            return adjustListType(ctx, this.getTypeUsage(ctx, {
-                schema: responseSchemas[0],
-                fallback: index_js_1.kt.refs.unit(),
-            }));
-        }
-        else if (responseSchemas.length === 0) {
-            return index_js_1.kt.refs.unit();
-        }
-        else {
-            // Under Spring Boot 4, this type flows into `ResponseEntity<T : Any>` (e.g. the delegate default methods),
-            // so the ambiguous/unknown-body fallback must be non-null `Any` rather than `Any?`.
-            return ctx.config.springBootVersion === 4 ? index_js_1.kt.refs.any() : index_js_1.kt.refs.any({ nullable: true });
-        }
-    }
-    getTypeUsage(ctx, args) {
-        var _a;
-        const { schema, nullable, fallback } = args;
-        const type = (_a = args.type) !== null && _a !== void 0 ? _a : this.getSchemaType(ctx, { schema });
-        return type
-            ? (0, core_1.createOverwriteProxy)(type, { nullable: nullable !== null && nullable !== void 0 ? nullable : type.nullable })
-            : (fallback !== null && fallback !== void 0 ? fallback : index_js_1.kt.refs.any({ nullable }));
-    }
-    getSchemaType(ctx, args) {
-        const { schema } = args;
-        return schema && ctx.input.kotlin.models[schema.id].type;
-    }
-    getEndpointDocDescription(ctx, args) {
-        var _a;
-        const docSegments = [(_a = args.endpoint.description) === null || _a === void 0 ? void 0 : _a.trim()];
-        if (ctx.config.includeSourceInDocs) {
-            docSegments.push((0, utils_js_1.getSourceDocLine)(args.endpoint));
-        }
-        return docSegments.filter(core_1.notNullish).join('\n\n');
-    }
-    getControllerRequestMapping(ctx, args) {
-        let { prefix } = args;
-        const basePath = this.getBasePath(ctx, {});
-        prefix !== null && prefix !== void 0 ? prefix : (prefix = `openapi.${(0, core_1.toCasing)(ctx.service.name, ctx.config.propertyNameCasing)}`);
-        return index_js_1.kt.string(`\${${prefix}.base-path:${basePath}}`);
-    }
-    getBasePath(ctx, _args) {
-        var _a, _b, _c, _d, _e, _f;
-        return (0, utils_js_1.modifyString)((_f = (_e = (_d = (_c = ((_a = ctx.service.$src) !== null && _a !== void 0 ? _a : (_b = ctx.service.endpoints[0]) === null || _b === void 0 ? void 0 : _b.$src)) === null || _c === void 0 ? void 0 : _c.document.servers) === null || _d === void 0 ? void 0 : _d[0]) === null || _e === void 0 ? void 0 : _e.url) !== null && _f !== void 0 ? _f : '/', ctx.config.basePath, ctx.service);
-    }
-    getEndpointPath(ctx, args) {
-        const { endpoint } = args;
-        return (0, utils_js_1.modifyString)(endpoint.path, ctx.config.pathModifier, endpoint);
-    }
-    getDirectoryPath(ctx, args) {
-        const { packageName } = args;
-        return `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}`;
-    }
-    getPathConstantName(ctx, args) {
-        const { endpoint } = args;
-        return (0, core_1.toCasing)(`${endpoint.name}_path`, ctx.config.constantNameCasing);
-    }
-    getPackageName(ctx, _args) {
-        const packageSuffix = typeof ctx.config.packageSuffix === 'string'
-            ? ctx.config.packageSuffix
-            : ctx.config.packageSuffix(ctx.service);
-        return ctx.config.packageName + packageSuffix;
-    }
-    getApiResponseEntityName(ctx, args) {
-        const { endpoint } = args;
-        return (0, core_1.toCasing)(`${endpoint.name}_ResponseEntity`, ctx.config.typeNameCasing);
-    }
-    getApiInterfaceName(ctx, _args) {
-        return (0, core_1.toCasing)(ctx.service.name + '_Api', ctx.config.typeNameCasing);
-    }
-    getApiControllerName(ctx, _args) {
-        return (0, core_1.toCasing)(ctx.service.name + '_ApiController', ctx.config.typeNameCasing);
-    }
-    getApiDelegateInterfaceName(ctx, _args) {
-        return (0, core_1.toCasing)(ctx.service.name + '_ApiDelegate', ctx.config.typeNameCasing);
-    }
-    getAllParameters(ctx, args) {
-        var _a, _b;
-        const { endpoint } = args;
-        const parameters = endpoint.parameters.filter((parameter) => parameter.target === 'query' ||
-            parameter.target === 'path' ||
-            parameter.target === 'header');
-        if (endpoint.requestBody) {
-            const content = endpoint.requestBody.content[0];
-            let schema = content.schema;
-            if (content.type === 'multipart/form-data') {
-                if (schema && schema.kind === 'object') {
-                    schema = (_a = (0, core_1.resolveAnyOfAndAllOf)(schema, true)) !== null && _a !== void 0 ? _a : schema;
-                    const properties = (_b = schema.properties) !== null && _b !== void 0 ? _b : {};
-                    for (const [name, property] of properties.entries()) {
-                        parameters.push(Object.assign(this.createApiParameter({
-                            id: `multipart-${name}`,
-                            name,
-                            target: 'body',
-                            schema: property.schema,
-                            required: schema.required.has(name),
-                            description: property.schema.description,
-                        }), {
-                            multipart: {
-                                name,
-                                isFile: property.schema.kind === 'string' &&
-                                    property.schema.format === 'binary',
-                            },
-                        }));
-                    }
-                }
-            }
-            else {
-                const schemaType = this.getSchemaType(ctx, { schema });
-                const name = !schemaType || /^Any\??$/.test(schemaType.name)
-                    ? 'body'
-                    : core_1.SourceBuilder.build((b) => index_js_1.kt.reference.write(b, schemaType));
-                parameters.push(this.createApiParameter({
-                    id: 'body',
-                    name,
-                    target: 'body',
-                    schema,
-                    required: endpoint.requestBody.required,
-                    description: endpoint.requestBody.description,
-                }));
-            }
-        }
-        return parameters;
-    }
-    createApiParameter(data) {
-        return {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            $src: undefined,
-            $ref: undefined,
-            schema: undefined,
-            required: false,
-            description: undefined,
-            allowEmptyValue: undefined,
-            allowReserved: undefined,
-            deprecated: false,
-            explode: undefined,
-            style: undefined,
-            ...data,
-        };
-    }
-}
-exports.DefaultKotlinSpringControllerGenerator = DefaultKotlinSpringControllerGenerator;
-function adjustListType(ctx, type) {
-    if (!index_js_1.kt.refs.list.matches(type))
-        return type;
-    switch (ctx.config.arrayType) {
-        case 'flux':
-            return index_js_1.kt.refs.reactor.flux([type.generics[0]]);
-        default:
-            return type;
-    }
-}