@goast/kotlin 0.1.18 → 0.2.0

package/esm/lib/generators/services/spring-controllers/spring-controller-generator.js

@@ -1,413 +1,340 @@
+/* eslint-disable unused-imports/no-unused-vars */
 import { ensureDirSync, writeFileSync } from 'fs-extra';
-import { notNullish, toCasing } from '@goast/core';
+import { SourceBuilder, appendValueGroup, builderTemplate as s, createOverwriteProxy, notNullish, toCasing, } from '@goast/core';
+import { kt } from '../../../ast';
 import { KotlinFileBuilder } from '../../../file-builder';
 import { modifyString } from '../../../utils';
 import { KotlinFileGenerator } from '../../file-generator';
 export class DefaultKotlinSpringControllerGenerator extends KotlinFileGenerator {
     generate(ctx) {
-        const packageName = this.getPackageName(ctx);
-        const dirPath = this.getDirectoryPath(ctx, packageName);
+        const packageName = this.getPackageName(ctx, {});
+        const dirPath = this.getDirectoryPath(ctx, { packageName });
         ensureDirSync(dirPath);
         console.log(`Generating service ${ctx.service.id} to ${dirPath}...`);
         return {
-            apiInterface: this.generateApiInterfaceFile(ctx, dirPath, packageName),
-            apiController: this.generateApiControllerFile(ctx, dirPath, packageName),
-            apiDelegate: this.generateApiDelegateInterfaceFile(ctx, dirPath, packageName),
+            apiInterface: this.generateApiInterfaceFile(ctx, { dirPath, packageName }),
+            apiController: this.generateApiControllerFile(ctx, { dirPath, packageName }),
+            apiDelegate: this.generateApiDelegateInterfaceFile(ctx, { dirPath, packageName }),
         };
     }
-    generateApiInterfaceFile(ctx, dirPath, packageName) {
-        const typeName = this.getApiInterfaceName(ctx);
+    // #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 KotlinFileBuilder(packageName, ctx.config);
-        this.generateApiInterfaceFileContent(ctx, builder);
+        builder.append(this.getApiInterfaceFileContent(ctx, { interfaceName: typeName }));
         writeFileSync(filePath, builder.toString());
-        return { typeName: builder.toString(), packageName };
-    }
-    generateApiInterfaceFileContent(ctx, builder) {
-        builder
-            .append((builder) => this.generateApiInterfaceAnnotations(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiInterfaceSignature(ctx, builder))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiInterfaceContent(ctx, builder), { multiline: true });
-    }
-    generateApiInterfaceAnnotations(ctx, builder) {
-        builder
-            .appendAnnotation('Validated', 'org.springframework.validation.annotation')
-            .appendAnnotation('RequestMapping', 'org.springframework.web.bind.annotation', [
-            this.getControllerRequestMapping(ctx, 'api'),
-        ]);
+        return { typeName, packageName };
+    }
+    getApiInterfaceFileContent(ctx, args) {
+        const { interfaceName } = args;
+        return appendValueGroup([this.getApiInterface(ctx, { interfaceName })], '\n');
     }
-    generateApiInterfaceSignature(ctx, builder) {
-        builder.append('interface ').append(this.getApiInterfaceName(ctx));
-    }
-    generateApiInterfaceContent(ctx, builder) {
-        builder
-            .append((builder) => this.generateApiInterfaceDelegateAccessor(ctx, builder))
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateApiInterfaceMethods(ctx, builder));
-    }
-    generateApiInterfaceDelegateAccessor(ctx, builder) {
-        builder.appendLine(`fun getDelegate(): ${this.getApiDelegateInterfaceName(ctx)} = object : ${this.getApiDelegateInterfaceName(ctx)} {}`);
-    }
-    generateApiInterfaceMethods(ctx, builder) {
-        builder.forEach(ctx.service.endpoints, (builder, endpoint) => builder.ensurePreviousLineEmpty().append((builder) => this.generateApiInterfaceMethod(ctx, builder, endpoint)));
-    }
-    generateApiInterfaceMethod(ctx, builder, endpoint) {
-        builder
-            .append((builder) => this.generateApiInterfaceMethodAnnnotations(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiInterfaceMethodSignature(ctx, builder, endpoint))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiInterfaceMethodContent(ctx, builder, endpoint), {
-            multiline: true,
+    getApiInterface(ctx, args) {
+        const { interfaceName } = args;
+        return kt.interface(interfaceName, {
+            annotations: this.getApiInterfaceAnnotations(ctx),
+            members: this.getApiInterfaceMembers(ctx),
         });
     }
-    generateApiInterfaceMethodAnnnotations(ctx, builder, endpoint) {
-        var _a;
-        builder
-            .if(ctx.config.addSwaggerAnnotations, (builder) => {
-            var _a, _b;
-            return builder.appendAnnotation('Operation', 'io.swagger.v3.oas.annotations', [
-                ['summary', this.toStringLiteral(ctx, (_a = endpoint.summary) === null || _a === void 0 ? void 0 : _a.trim())],
-                ['operationId', this.toStringLiteral(ctx, endpoint.name)],
-                ['description', this.toStringLiteral(ctx, (_b = endpoint.description) === null || _b === void 0 ? void 0 : _b.trim())],
-                [
-                    'responses',
-                    (builder) => builder.parenthesize('[]', (builder) => builder.forEach(endpoint.responses, (builder, response) => builder
-                        .append('ApiResponse')
-                        .addImport('ApiResponse', 'io.swagger.v3.oas.annotations.responses')
-                        .parenthesize('()', (builder) => {
-                        var _a, _b;
-                        return builder
-                            .append(`responseCode = ${this.toStringLiteral(ctx, (_a = response.statusCode) === null || _a === void 0 ? void 0 : _a.toString())}, `)
-                            .append(`description = ${this.toStringLiteral(ctx, (_b = response.description) === null || _b === void 0 ? void 0 : _b.trim())}`);
-                    }), { separator: ',\n' }), { multiline: true }),
-                    endpoint.responses.length > 0,
-                ],
-            ]);
-        })
-            .appendAnnotation('RequestMapping', 'org.springframework.web.bind.annotation', [
-            ['method', '[RequestMethod.' + endpoint.method.toUpperCase() + ']'],
-            ['value', '[' + this.toStringLiteral(ctx, this.getEndpointPath(ctx, endpoint)) + ']'],
-            [
-                'consumes',
-                '[' + ((_a = endpoint.requestBody) === null || _a === void 0 ? void 0 : _a.content.map((x) => this.toStringLiteral(ctx, x.type)).join(', ')) + ']',
-                !!endpoint.requestBody && endpoint.requestBody.content.length > 0,
-            ],
-        ])
-            .addImport('RequestMethod', 'org.springframework.web.bind.annotation');
-    }
-    generateApiInterfaceMethodSignature(ctx, builder, endpoint) {
-        builder
-            .append(`suspend fun ${toCasing(endpoint.name, 'camel')}`)
-            .parenthesize('()', (builder) => this.generateApiInterfaceMethodParameters(ctx, builder, endpoint), {
-            multiline: true,
-        })
-            .append(': ')
-            .append((builder) => this.generateApiInterfaceMethodReturnType(ctx, builder, endpoint));
-    }
-    generateApiInterfaceMethodParameters(ctx, builder, endpoint) {
-        const parameters = this.getAllParameters(ctx, endpoint);
-        builder.forEach(parameters, (builder, parameter) => this.generateApiInterfaceMethodParameter(ctx, builder, endpoint, parameter), { separator: ',\n' });
-    }
-    generateApiInterfaceMethodReturnType(ctx, builder, endpoint) {
-        this.generateResponseEntityType(ctx, builder, endpoint);
-    }
-    generateApiInterfaceMethodParameter(ctx, builder, endpoint, parameter) {
-        builder
-            .append((builder) => this.generateApiInterfaceMethodParameterAnnotations(ctx, builder, endpoint, parameter))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiInterfaceMethodParameterSignature(ctx, builder, endpoint, parameter));
-    }
-    generateApiInterfaceMethodParameterAnnotations(ctx, builder, endpoint, parameter) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        const parameterSchemaInfo = this.getSchemaInfo(ctx, parameter.schema);
+    getApiInterfaceAnnotations(ctx) {
+        const validated = kt.annotation(kt.refs.spring.validated());
+        const requestMapping = kt.annotation(kt.refs.spring.requestMapping(), [
+            kt.argument(this.getControllerRequestMapping(ctx, { prefix: 'api' })),
+        ]);
+        return [validated, requestMapping];
+    }
+    getApiInterfaceMembers(ctx) {
+        const members = [];
+        const delegateInterfaceName = this.getApiDelegateInterfaceName(ctx, {});
+        members.push(kt.function('getDelegate', {
+            returnType: delegateInterfaceName,
+            singleExpression: true,
+            body: kt.object({
+                implements: [delegateInterfaceName],
+            }),
+        }));
+        ctx.service.endpoints.forEach((endpoint) => {
+            members.push(this.getApiInterfaceEndpointMethod(ctx, { endpoint }));
+        });
+        return members;
+    }
+    getApiInterfaceEndpointMethod(ctx, args) {
+        const { endpoint } = args;
+        const parameters = this.getAllParameters(ctx, { endpoint });
+        return kt.function(toCasing(endpoint.name, ctx.config.functionNameCasing), {
+            suspend: true,
+            annotations: this.getApiInterfaceEndpointMethodAnnnotations(ctx, endpoint),
+            parameters: parameters.map((parameter) => this.getApiInterfaceEndpointMethodParameter(ctx, endpoint, parameter)),
+            returnType: kt.refs.spring.responseEntity([this.getResponseType(ctx, { endpoint })]),
+            body: this.getApiInterfaceEndpointMethodBody(ctx, endpoint, parameters),
+        });
+    }
+    getApiInterfaceEndpointMethodAnnnotations(ctx, endpoint) {
+        var _a, _b, _c;
+        const operation = kt.annotation(kt.refs.swagger.operation(), [
+            kt.argument.named('summary', kt.string((_a = endpoint.summary) === null || _a === void 0 ? void 0 : _a.trim())),
+            kt.argument.named('operationId', kt.string(endpoint.name)),
+            kt.argument.named('description', kt.string((_b = endpoint.description) === null || _b === void 0 ? void 0 : _b.trim())),
+            kt.argument.named('responses', kt.collectionLiteral(endpoint.responses.map((response) => {
+                var _a, _b;
+                return kt.call(kt.refs.swagger.apiResponse(), [
+                    kt.argument.named('responseCode', kt.string((_a = response.statusCode) === null || _a === void 0 ? void 0 : _a.toString())),
+                    kt.argument.named('description', kt.string((_b = response.description) === null || _b === void 0 ? void 0 : _b.trim())),
+                ]);
+            }))),
+        ]);
+        const requestMapping = kt.annotation(kt.refs.spring.requestMapping(), [
+            kt.argument.named('method', kt.collectionLiteral([kt.call([kt.refs.spring.requestMethod(), endpoint.method.toUpperCase()])])),
+            kt.argument.named('value', kt.collectionLiteral([kt.string(this.getEndpointPath(ctx, { endpoint }))])),
+        ]);
+        if (endpoint.requestBody && endpoint.requestBody.content.length > 0) {
+            requestMapping.arguments.push(kt.argument.named('consumes', kt.collectionLiteral((_c = endpoint.requestBody) === null || _c === void 0 ? void 0 : _c.content.map((x) => kt.string(x.type)))));
+        }
+        return [operation, requestMapping];
+    }
+    getApiInterfaceEndpointMethodParameter(ctx, endpoint, parameter) {
+        var _a, _b, _c, _d, _e;
+        const schemaType = this.getSchemaType(ctx, { schema: parameter.schema });
+        const result = kt.parameter(toCasing(parameter.name, ctx.config.parameterNameCasing), this.getParameterType(ctx, { endpoint, parameter }), {});
         if (ctx.config.addSwaggerAnnotations) {
-            if (((_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.default) !== undefined) {
-                builder.addImport('Schema', 'io.swagger.v3.oas.annotations.media');
-            }
-            builder.appendAnnotation('Parameter', 'io.swagger.v3.oas.annotations', [
-                ['description', this.toStringLiteral(ctx, (_b = parameter.description) === null || _b === void 0 ? void 0 : _b.trim())],
-                ['required', (_c = parameter.required) === null || _c === void 0 ? void 0 : _c.toString()],
-                [
-                    'schema',
-                    `Schema(defaultValue = ${this.toStringLiteral(ctx, String((_d = parameter.schema) === null || _d === void 0 ? void 0 : _d.default))})`,
-                    ((_e = parameter.schema) === null || _e === void 0 ? void 0 : _e.default) !== undefined,
-                ],
+            const annotation = kt.annotation(kt.refs.swagger.parameter(), [
+                kt.argument.named('description', kt.string((_a = parameter.description) === null || _a === void 0 ? void 0 : _a.trim())),
+                kt.argument.named('required', parameter.required),
             ]);
+            if (((_b = parameter.schema) === null || _b === void 0 ? void 0 : _b.default) !== undefined) {
+                annotation.arguments.push(kt.argument.named('schema', kt.call([kt.refs.swagger.schema()], [kt.argument.named('defaultValue', kt.string(String((_c = parameter.schema) === null || _c === void 0 ? void 0 : _c.default)))])));
+            }
+            result.annotations.push(annotation);
         }
-        if (parameterSchemaInfo.packageName && ctx.config.addJakartaValidationAnnotations) {
-            builder.appendAnnotation('Valid', 'jakarta.validation');
+        const isCorePackage = !(schemaType === null || schemaType === void 0 ? void 0 : schemaType.packageName) || /^(kotlin|java)(\..*|$)/.test(schemaType.packageName);
+        if (!isCorePackage && ctx.config.addJakartaValidationAnnotations) {
+            result.annotations.push(kt.annotation(kt.refs.jakarta.valid()));
         }
         if (parameter.target === 'body') {
-            builder.appendAnnotation('RequestBody', 'org.springframework.web.bind.annotation');
+            result.annotations.push(kt.annotation(kt.refs.spring.requestBody()));
         }
         if (parameter.target === 'query') {
-            builder.appendAnnotation('RequestParam', 'org.springframework.web.bind.annotation', [
-                ['value', this.toStringLiteral(ctx, parameter.name)],
-                ['required', (_f = parameter.required) === null || _f === void 0 ? void 0 : _f.toString()],
-                [
-                    'defaultValue',
-                    this.toStringLiteral(ctx, String((_g = parameter.schema) === null || _g === void 0 ? void 0 : _g.default)),
-                    ((_h = parameter.schema) === null || _h === void 0 ? void 0 : _h.default) !== undefined,
-                ],
+            const annotation = kt.annotation(kt.refs.spring.requestParam(), [
+                kt.argument.named('value', kt.string(parameter.name)),
+                kt.argument.named('required', parameter.required),
             ]);
+            if (((_d = parameter.schema) === null || _d === void 0 ? void 0 : _d.default) !== undefined) {
+                annotation.arguments.push(kt.argument.named('defaultValue', kt.string(String((_e = parameter.schema) === null || _e === void 0 ? void 0 : _e.default))));
+            }
+            result.annotations.push(annotation);
         }
         if (parameter.target === 'path') {
-            builder.appendAnnotation('PathVariable', 'org.springframework.web.bind.annotation', [
-                this.toStringLiteral(ctx, parameter.name),
-            ]);
+            result.annotations.push(kt.annotation(kt.refs.spring.pathVariable(), [kt.string(parameter.name)]));
         }
-    }
-    generateApiInterfaceMethodParameterSignature(ctx, builder, endpoint, parameter) {
-        var _a, _b;
-        builder
-            .append(toCasing(parameter.name, 'camel'))
-            .append(': ')
-            .append((builder) => this.generateTypeUsage(ctx, builder, parameter.schema, parameter.target === 'body'))
-            .append(!parameter.required && ((_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.default) === undefined && !((_b = parameter.schema) === null || _b === void 0 ? void 0 : _b.nullable) ? '?' : '');
-    }
-    generateApiInterfaceMethodContent(ctx, builder, endpoint) {
-        const parameters = this.getAllParameters(ctx, endpoint);
-        builder
-            .append(`return getDelegate().${toCasing(endpoint.name, 'camel')}(`)
-            .forEach(parameters, (builder, parameter) => builder.append(toCasing(parameter.name, 'camel')), {
-            separator: ', ',
-        })
-            .append(')');
-    }
-    generateApiControllerFile(ctx, dirPath, packageName) {
-        const typeName = this.getApiControllerName(ctx);
+        return result;
+    }
+    getApiInterfaceEndpointMethodBody(ctx, endpoint, parameters) {
+        return appendValueGroup([
+            s `return ${kt.call([kt.call(kt.reference('getDelegate'), []), toCasing(endpoint.name, ctx.config.functionNameCasing)], parameters.map((x) => toCasing(x.name, ctx.config.parameterNameCasing)))}`,
+        ], '\n');
+    }
+    // #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 KotlinFileBuilder(packageName, ctx.config);
-        this.generateApiControllerFileContent(ctx, builder);
+        builder.append(this.getApiControllerFileContent(ctx, { controllerName: typeName }));
         writeFileSync(filePath, builder.toString());
-        return { typeName: builder.toString(), packageName };
-    }
-    generateApiControllerFileContent(ctx, builder) {
-        builder
-            .append((builder) => this.generateApiControllerAnnotations(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiControllerSignature(ctx, builder))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiControllerContent(ctx, builder), { multiline: true });
-    }
-    generateApiControllerAnnotations(ctx, builder) {
-        builder
-            .if(ctx.config.addJakartaValidationAnnotations, (builder) => builder.appendAnnotation('Generated', 'jakarta.annotation', [
-            ['value', '[' + this.toStringLiteral(ctx, 'com.goast.kotlin.spring-service-generator') + ']'],
-        ]))
-            .appendAnnotation('Controller', 'org.springframework.stereotype')
-            .appendAnnotation('RequestMapping', 'org.springframework.web.bind.annotation', [
-            this.getControllerRequestMapping(ctx),
-        ]);
+        return { typeName, packageName };
+    }
+    getApiControllerFileContent(ctx, args) {
+        const { controllerName } = args;
+        return appendValueGroup([this.getApiController(ctx, { controllerName })], '\n');
+    }
+    getApiController(ctx, args) {
+        const { controllerName } = args;
+        return kt.class(controllerName, {
+            annotations: this.getApiControllerAnnotations(ctx),
+            primaryConstructor: kt.constructor([
+                kt.parameter.class('delegate', kt.reference(this.getApiDelegateInterfaceName(ctx, {}), null, { nullable: true }), {
+                    annotations: [kt.annotation(kt.refs.spring.autowired(), [kt.argument.named('required', 'false')])],
+                }),
+            ]),
+            implements: [this.getApiInterfaceName(ctx, {})],
+            members: this.getApiControllerMembers(ctx),
+        });
     }
-    generateApiControllerSignature(ctx, builder) {
-        builder
-            .append('class ')
-            .append(this.getApiControllerName(ctx))
-            .parenthesize('()', (builder) => this.generateApiControllerParameters(ctx, builder), { multiline: true })
-            .append(' : ')
-            .append(this.getApiInterfaceName(ctx));
-    }
-    generateApiControllerParameters(ctx, builder) {
-        builder
-            .appendAnnotation('Autowired', 'org.springframework.beans.factory.annotation', [['required', 'false']])
-            .append('delegate: ')
-            .append(this.getApiDelegateInterfaceName(ctx))
-            .append('?');
-    }
-    generateApiControllerContent(ctx, builder) {
-        builder
-            .append('private val delegate: ')
-            .appendLine(this.getApiDelegateInterfaceName(ctx))
-            .appendLine()
-            .append('init ')
-            .parenthesize('{}', (builder) => builder
-            .append('this.delegate = Optional.ofNullable(delegate).orElse')
-            .addImport('Optional', 'java.util')
-            .parenthesize('()', (builder) => builder.append('object : ').append(this.getApiDelegateInterfaceName(ctx)).append(' {}')), { multiline: true })
-            .appendLine()
-            .appendLine()
-            .appendLine(`override fun getDelegate(): ${this.getApiDelegateInterfaceName(ctx)} = delegate`);
-    }
-    generateApiDelegateInterfaceFile(ctx, dirPath, packageName) {
-        const typeName = this.getApiDelegateInterfaceName(ctx);
+    getApiControllerAnnotations(ctx) {
+        const annotations = [];
+        if (ctx.config.addJakartaValidationAnnotations) {
+            annotations.push(kt.annotation(kt.refs.jakarta.generated(), [
+                kt.argument.named('value', kt.collectionLiteral([kt.string('com.goast.kotlin.spring-service-generator')])),
+            ]));
+        }
+        annotations.push(kt.annotation(kt.refs.spring.controller()));
+        annotations.push(kt.annotation(kt.refs.spring.requestMapping(), [this.getControllerRequestMapping(ctx, {})]));
+        return annotations;
+    }
+    getApiControllerMembers(ctx) {
+        const delegateInterfaceName = this.getApiDelegateInterfaceName(ctx, {});
+        const delegateProp = kt.property('delegate', {
+            accessModifier: 'private',
+            type: kt.reference(delegateInterfaceName),
+        });
+        const initBlock = kt.initBlock(appendValueGroup([
+            s `this.delegate = ${kt.refs.java.optional.infer()}.ofNullable(delegate).orElse(object : ${delegateInterfaceName} {})`,
+        ], '\n'));
+        const getDelegateFun = kt.function('getDelegate', {
+            override: true,
+            returnType: delegateInterfaceName,
+            singleExpression: true,
+            body: kt.reference('delegate'),
+        });
+        return [delegateProp, initBlock, getDelegateFun];
+    }
+    // #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 KotlinFileBuilder(packageName, ctx.config);
-        this.generateApiDelegateInterfaceFileContent(ctx, builder);
+        builder.append(this.getApiDelegateInterfaceFileContent(ctx, { delegateInterfaceName: typeName }));
         writeFileSync(filePath, builder.toString());
-        return { typeName: builder.toString(), packageName };
+        return { typeName, packageName };
+    }
+    getApiDelegateInterfaceFileContent(ctx, args) {
+        const { delegateInterfaceName } = args;
+        return appendValueGroup([this.getApiDelegateInterface(ctx, { delegateInterfaceName })], '\n');
     }
-    generateApiDelegateInterfaceFileContent(ctx, builder) {
-        builder
-            .append((builder) => this.generateApiDelegateInterfaceAnnotations(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiDelegateInterfaceSignature(ctx, builder))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiDelegateInterfaceContent(ctx, builder), { multiline: true });
+    getApiDelegateInterface(ctx, args) {
+        const { delegateInterfaceName } = args;
+        return kt.interface(delegateInterfaceName, {
+            annotations: this.getApiDelegateInterfaceAnnotations(ctx),
+            members: this.getApiDelegateInterfaceMembers(ctx),
+        });
     }
-    generateApiDelegateInterfaceAnnotations(ctx, builder) {
+    getApiDelegateInterfaceAnnotations(ctx) {
+        const annotations = [];
         if (ctx.config.addJakartaValidationAnnotations) {
-            builder.appendAnnotation('Generated', 'jakarta.annotation', [
-                ['value', '[' + this.toStringLiteral(ctx, 'com.goast.kotlin.spring-service-generator') + ']'],
-            ]);
+            annotations.push(kt.annotation(kt.refs.jakarta.generated(), [
+                kt.argument.named('value', kt.collectionLiteral([kt.string('com.goast.kotlin.spring-service-generator')])),
+            ]));
         }
-    }
-    generateApiDelegateInterfaceSignature(ctx, builder) {
-        builder.append('interface ').append(this.getApiDelegateInterfaceName(ctx));
-    }
-    generateApiDelegateInterfaceContent(ctx, builder) {
-        builder
-            .appendLine(`fun getRequest(): Optional<NativeWebRequest> = Optional.empty()`)
-            .addImport('Optional', 'java.util')
-            .addImport('NativeWebRequest', 'org.springframework.web.context.request')
-            .forEach(ctx.service.endpoints, (builder, endpoint) => builder
-            .ensurePreviousLineEmpty()
-            .append((builder) => this.generateApiDelegateInterfaceMethod(ctx, builder, endpoint)));
-    }
-    generateApiDelegateInterfaceMethod(ctx, builder, endpoint) {
-        builder
-            .append((builder) => this.generateApiDelegateInterfaceMethodAnnnotations(ctx, builder, endpoint))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiDelegateInterfaceMethodSignature(ctx, builder, endpoint))
-            .append(' ')
-            .parenthesize('{}', (builder) => this.generateApiDelegateInterfaceMethodContent(ctx, builder, endpoint), {
-            multiline: true,
+        return annotations;
+    }
+    getApiDelegateInterfaceMembers(ctx) {
+        const members = [];
+        members.push(kt.function('getRequest', {
+            returnType: kt.refs.java.optional([kt.refs.spring.nativeWebRequest()]),
+            singleExpression: true,
+            body: kt.call([kt.refs.java.optional.infer(), 'empty'], []),
+        }));
+        ctx.service.endpoints.forEach((endpoint) => {
+            members.push(this.getApiDelegateInterfaceEndpointMethod(ctx, { endpoint }));
         });
-    }
-    generateApiDelegateInterfaceMethodAnnnotations(ctx, builder, endpoint) {
-        // None for now.
-    }
-    generateApiDelegateInterfaceMethodSignature(ctx, builder, endpoint) {
-        builder
-            .append(`suspend fun ${toCasing(endpoint.name, 'camel')}`)
-            .parenthesize('()', (builder) => this.generateApiDelegateInterfaceMethodParameters(ctx, builder, endpoint), {
-            multiline: true,
-        })
-            .append(': ')
-            .append((builder) => this.generateApiDelegateInterfaceMethodReturnType(ctx, builder, endpoint));
-    }
-    generateApiDelegateInterfaceMethodParameters(ctx, builder, endpoint) {
-        const parameters = this.getAllParameters(ctx, endpoint);
-        builder.forEach(parameters, (builder, parameter) => this.generateApiDelegateInterfaceMethodParameter(ctx, builder, endpoint, parameter), { separator: ',\n' });
-    }
-    generateApiDelegateInterfaceMethodReturnType(ctx, builder, endpoint) {
-        this.generateResponseEntityType(ctx, builder, endpoint);
-    }
-    generateApiDelegateInterfaceMethodParameter(ctx, builder, endpoint, parameter) {
-        builder
-            .append((builder) => this.generateApiDelegateInterfaceMethodParameterAnnotations(ctx, builder, endpoint, parameter))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateApiDelegateInterfaceMethodParameterSignature(ctx, builder, endpoint, parameter));
-    }
-    generateApiDelegateInterfaceMethodParameterAnnotations(ctx, builder, endpoint, parameter) {
-        // None for now.
-    }
-    generateApiDelegateInterfaceMethodParameterSignature(ctx, builder, endpoint, parameter) {
-        var _a, _b;
-        builder
-            .append(toCasing(parameter.name, 'camel'))
-            .append(': ')
-            .append((builder) => this.generateTypeUsage(ctx, builder, parameter.schema, parameter.target === 'body'))
-            .append(!parameter.required && ((_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.default) === undefined && !((_b = parameter.schema) === null || _b === void 0 ? void 0 : _b.nullable) ? '?' : '');
-    }
-    generateApiDelegateInterfaceMethodContent(ctx, builder, endpoint) {
-        builder
-            .appendLine('return ResponseEntity(HttpStatus.NOT_IMPLEMENTED)')
-            .addImport('ResponseEntity', 'org.springframework.http')
-            .addImport('HttpStatus', 'org.springframework.http');
-    }
-    generateResponseEntityType(ctx, builder, endpoint) {
-        builder
-            .append('ResponseEntity')
-            .addImport('ResponseEntity', 'org.springframework.http')
-            .parenthesize('<>', (builder) => {
-            const responseSchemas = endpoint.responses
-                .flatMap((x) => x.contentOptions.flatMap((x) => x.schema))
-                .filter(notNullish)
-                .filter((x, i, a) => a.findIndex((y) => {
-                const xInfo = this.getSchemaInfo(ctx, x);
-                const yInfo = this.getSchemaInfo(ctx, y);
-                return xInfo.typeName === yInfo.typeName && xInfo.packageName === yInfo.packageName;
-            }) === i);
-            if (responseSchemas.length === 1) {
-                this.generateTypeUsage(ctx, builder, responseSchemas[0], true, 'Unit');
-            }
-            else if (responseSchemas.length === 0) {
-                builder.append('Unit');
-            }
-            else {
-                builder.append('Any?');
-            }
+        return members;
+    }
+    getApiDelegateInterfaceEndpointMethod(ctx, args) {
+        const { endpoint } = args;
+        const parameters = this.getAllParameters(ctx, { endpoint });
+        return kt.function(toCasing(endpoint.name, ctx.config.functionNameCasing), {
+            suspend: true,
+            parameters: parameters.map((parameter) => {
+                return kt.parameter(toCasing(parameter.name, ctx.config.parameterNameCasing), this.getParameterType(ctx, { endpoint, parameter }));
+            }),
+            returnType: kt.refs.spring.responseEntity([this.getResponseType(ctx, { endpoint })]),
+            body: appendValueGroup([s `return ${kt.refs.spring.responseEntity.infer()}(${kt.refs.spring.httpStatus()}.NOT_IMPLEMENTED)`], '\n'),
         });
     }
-    generateTypeUsage(ctx, builder, schema, arrayAsFlux, fallback) {
-        if (schema && schema.kind === 'array') {
-            const schemaInfo = this.getSchemaInfo(ctx, schema.items);
-            if (arrayAsFlux) {
-                builder.append(`Flux<${schemaInfo.typeName}>`).addImport('Flux', 'reactor.core.publisher');
-            }
-            else {
-                builder.append(`List<${schemaInfo.typeName}>`);
-            }
-            builder.imports.addImports([schemaInfo, ...schemaInfo.additionalImports]);
+    // #endregion
+    getParameterType(ctx, args) {
+        var _a;
+        const { parameter } = args;
+        const type = this.getTypeUsage(ctx, {
+            schema: parameter.schema,
+            nullable: (!parameter.required && ((_a = parameter.schema) === null || _a === void 0 ? void 0 : _a.default) === undefined) || undefined,
+        });
+        return parameter.target === 'body' ? listToFlux(type) : type;
+    }
+    getResponseType(ctx, args) {
+        const { endpoint } = args;
+        const responseSchemas = endpoint.responses
+            .flatMap((x) => x.contentOptions.flatMap((x) => x.schema))
+            .filter(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 listToFlux(this.getTypeUsage(ctx, { schema: responseSchemas[0], fallback: kt.refs.unit() }));
         }
-        else if (schema || !fallback) {
-            const schemaInfo = this.getSchemaInfo(ctx, schema);
-            builder.append(schemaInfo.typeName);
-            builder.imports.addImports([schemaInfo, ...schemaInfo.additionalImports]);
+        else if (responseSchemas.length === 0) {
+            return kt.refs.unit();
         }
         else {
-            builder.append(fallback);
+            return kt.refs.any({ nullable: true });
         }
     }
-    getControllerRequestMapping(ctx, prefix) {
-        const basePath = this.getBasePath(ctx);
-        prefix !== null && prefix !== void 0 ? prefix : (prefix = `openapi.${toCasing(ctx.service.name, 'camel')}`);
-        return this.toStringLiteral(ctx, `\${${prefix}.base-path:${basePath}}`);
+    getTypeUsage(ctx, args) {
+        const { schema, nullable, fallback } = args;
+        const type = this.getSchemaType(ctx, { schema });
+        return type
+            ? createOverwriteProxy(type, { nullable: nullable !== null && nullable !== void 0 ? nullable : type.nullable })
+            : fallback !== null && fallback !== void 0 ? fallback : kt.refs.any({ nullable });
+    }
+    getSchemaType(ctx, args) {
+        const { schema } = args;
+        return schema && ctx.input.models[schema.id].type;
+    }
+    getControllerRequestMapping(ctx, args) {
+        let { prefix } = args;
+        const basePath = this.getBasePath(ctx, {});
+        prefix !== null && prefix !== void 0 ? prefix : (prefix = `openapi.${toCasing(ctx.service.name, ctx.config.propertyNameCasing)}`);
+        return kt.string(`\${${prefix}.base-path:${basePath}}`);
     }
-    getBasePath(ctx) {
+    getBasePath(ctx, args) {
         var _a, _b, _c, _d, _e, _f;
         return 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, endpoint) {
+    getEndpointPath(ctx, args) {
+        const { endpoint } = args;
         return modifyString(endpoint.path, ctx.config.pathModifier, endpoint);
     }
-    getDirectoryPath(ctx, packageName) {
+    getDirectoryPath(ctx, args) {
+        const { packageName } = args;
         return `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}`;
     }
-    getPackageName(ctx) {
+    getPackageName(ctx, args) {
         const packageSuffix = typeof ctx.config.packageSuffix === 'string' ? ctx.config.packageSuffix : ctx.config.packageSuffix(ctx.service);
         return ctx.config.packageName + packageSuffix;
     }
-    getApiInterfaceName(ctx) {
-        return toCasing(ctx.service.name, 'pascal') + 'Api';
+    getApiInterfaceName(ctx, args) {
+        return toCasing(ctx.service.name + '_Api', ctx.config.typeNameCasing);
     }
-    getApiControllerName(ctx) {
-        return toCasing(ctx.service.name, 'pascal') + 'ApiController';
+    getApiControllerName(ctx, args) {
+        return toCasing(ctx.service.name + '_ApiController', ctx.config.typeNameCasing);
     }
-    getApiDelegateInterfaceName(ctx) {
-        return toCasing(ctx.service.name, 'pascal') + 'ApiDelegate';
+    getApiDelegateInterfaceName(ctx, args) {
+        return toCasing(ctx.service.name + '_ApiDelegate', ctx.config.typeNameCasing);
     }
-    getSchemaInfo(ctx, schema) {
-        var _a;
-        return ((_a = (schema && ctx.input.models[schema.id])) !== null && _a !== void 0 ? _a : { typeName: 'Any?', packageName: undefined, additionalImports: [] });
-    }
-    getAllParameters(ctx, endpoint) {
+    getAllParameters(ctx, args) {
+        const { endpoint } = args;
         const parameters = endpoint.parameters.filter((parameter) => parameter.target === 'query' || parameter.target === 'path');
         if (endpoint.requestBody) {
             const schema = endpoint.requestBody.content[0].schema;
-            const schemaInfo = this.getSchemaInfo(ctx, schema);
-            const name = /^Any\??$/.test(schemaInfo.typeName) ? 'body' : schemaInfo.typeName;
+            const schemaType = this.getSchemaType(ctx, { schema });
+            const name = !schemaType || /^Any\??$/.test(schemaType.name)
+                ? 'body'
+                : SourceBuilder.build((b) => kt.reference.write(b, schemaType));
             parameters.push({
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 $src: undefined,
                 $ref: undefined,
                 id: 'body',
@@ -425,11 +352,7 @@ export class DefaultKotlinSpringControllerGenerator extends KotlinFileGenerator
         }
         return parameters;
     }
-    sortParameters(ctx, parameters) {
-        return [...parameters].sort((a, b) => {
-            const aRequired = a.required ? 1 : 0;
-            const bRequired = b.required ? 1 : 0;
-            return aRequired - bRequired;
-        });
-    }
+}
+export function listToFlux(type) {
+    return kt.refs.list.matches(type) ? kt.refs.reactor.flux([type.generics[0]]) : type;
 }