@goast/kotlin 0.0.1

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

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultKotlinSpringControllerGenerator = void 0;
+const fs_extra_1 = require("fs-extra");
+const core_1 = require("@goast/core");
+const file_builder_1 = require("../../../file-builder");
+const file_generator_1 = require("../../file-generator");
+class DefaultKotlinSpringControllerGenerator extends file_generator_1.KotlinFileGenerator {
+    generate(ctx) {
+        const packageName = this.getPackageName(ctx);
+        const dirPath = this.getDirectoryPath(ctx, packageName);
+        (0, fs_extra_1.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),
+        };
+    }
+    generateApiInterfaceFile(ctx, dirPath, packageName) {
+        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_1.KotlinFileBuilder(packageName, ctx.config);
+        this.generateApiInterfaceFileContent(ctx, builder);
+        (0, fs_extra_1.writeFileSync)(filePath, builder.toString());
+        return { typeName: builder.toString(), packageName };
+    }
+    generateApiInterfaceFileContent(ctx, builder) {
+        builder
+            .apply((builder) => this.generateApiInterfaceAnnotations(ctx, builder))
+            .ensureCurrentLineEmpty()
+            .apply((builder) => this.generateApiInterfaceSignature(ctx, builder))
+            .append(' ')
+            .parenthesize('{}', (builder) => builder
+            .appendLine()
+            .apply((builder) => this.generateApiInterfaceContent(ctx, builder))
+            .ensureCurrentLineEmpty());
+    }
+    generateApiInterfaceAnnotations(ctx, builder) {
+        builder
+            .appendAnnotation('Validated', 'org.springframework.validation.annotation')
+            .appendAnnotation('RequestMapping', 'org.springframework.web.bind.annotation', [
+            this.getControllerRequestMapping(ctx, 'api'),
+        ]);
+    }
+    generateApiInterfaceSignature(ctx, builder) {
+        builder.append('interface ').append(this.getApiInterfaceName(ctx));
+    }
+    generateApiInterfaceContent(ctx, builder) {
+        builder
+            .apply((builder) => this.generateApiInterfaceDelegateAccessor(ctx, builder))
+            .ensurePreviousLineEmpty()
+            .apply((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().apply((builder) => this.generateApiInterfaceMethod(ctx, builder, endpoint)));
+    }
+    generateApiInterfaceMethod(ctx, builder, endpoint) {
+        builder
+            .apply((builder) => this.generateApiInterfaceMethodAnnnotations(ctx, builder, endpoint))
+            .ensureCurrentLineEmpty()
+            .apply((builder) => this.generateApiInterfaceMethodSignature(ctx, builder, endpoint))
+            .append(' ')
+            .parenthesize('{}', (builder) => builder
+            .appendLine()
+            .apply((builder) => this.generateApiInterfaceMethodContent(ctx, builder, endpoint))
+            .appendLine());
+    }
+    generateApiInterfaceMethodAnnnotations(ctx, builder, endpoint) {
+        var _a, _b, _c;
+        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
+                    .appendLine()
+                    .forEachSeparated(endpoint.responses, ',\n', (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())}`);
+                }))
+                    .appendLine()),
+                endpoint.responses.length > 0,
+            ],
+        ])
+            .appendAnnotation('RequestMapping', 'org.springframework.web.bind.annotation', [
+            ['method', '[RequestMethod.' + endpoint.method.toUpperCase() + ']'],
+            ['value', '[' + this.toStringLiteral(ctx, endpoint.path) + ']'],
+            [
+                'consumes',
+                '[' + ((_c = endpoint.requestBody) === null || _c === void 0 ? void 0 : _c.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 ${(0, core_1.toCasing)(endpoint.name, 'camel')}`)
+            .parenthesize('()', (builder) => builder
+            .appendLine()
+            .apply((builder) => this.generateApiInterfaceMethodParameters(ctx, builder, endpoint))
+            .appendLine())
+            .append(': ')
+            .apply((builder) => this.generateApiInterfaceMethodReturnType(ctx, builder, endpoint));
+    }
+    generateApiInterfaceMethodParameters(ctx, builder, endpoint) {
+        const parameters = this.getAllParameters(ctx, endpoint);
+        builder.forEachSeparated(parameters, ',\n', (builder, parameter) => this.generateApiInterfaceMethodParameter(ctx, builder, endpoint, parameter));
+    }
+    generateApiInterfaceMethodReturnType(ctx, builder, endpoint) {
+        var _a, _b;
+        this.generateResponseEntityType(ctx, builder, (_b = (_a = endpoint.responses[0]) === null || _a === void 0 ? void 0 : _a.contentOptions[0]) === null || _b === void 0 ? void 0 : _b.schema);
+    }
+    generateApiInterfaceMethodParameter(ctx, builder, endpoint, parameter) {
+        builder
+            .apply((builder) => this.generateApiInterfaceMethodParameterAnnotations(ctx, builder, endpoint, parameter))
+            .ensureCurrentLineEmpty()
+            .apply((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);
+        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,
+            ],
+        ]);
+        if (parameterSchemaInfo.packageName) {
+            builder.appendAnnotation('Valid', 'jakarta.validation');
+        }
+        if (parameter.target === 'body') {
+            builder.appendAnnotation('RequestBody', 'org.springframework.web.bind.annotation');
+        }
+        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,
+                ],
+            ]);
+        }
+        if (parameter.target === 'path') {
+            builder.appendAnnotation('PathVariable', 'org.springframework.web.bind.annotation', [
+                this.toStringLiteral(ctx, parameter.name),
+            ]);
+        }
+    }
+    generateApiInterfaceMethodParameterSignature(ctx, builder, endpoint, parameter) {
+        builder
+            .append((0, core_1.toCasing)(parameter.name, 'camel'))
+            .append(': ')
+            .apply((builder) => this.generateTypeUsage(ctx, builder, parameter.schema));
+    }
+    generateApiInterfaceMethodContent(ctx, builder, endpoint) {
+        const parameters = this.getAllParameters(ctx, endpoint);
+        builder
+            .append(`return getDelegate().${(0, core_1.toCasing)(endpoint.name, 'camel')}(`)
+            .forEachSeparated(parameters, ', ', (builder, parameter) => builder.append((0, core_1.toCasing)(parameter.name, 'camel')))
+            .append(')');
+    }
+    generateApiControllerFile(ctx, dirPath, packageName) {
+        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_1.KotlinFileBuilder(packageName, ctx.config);
+        this.generateApiControllerFileContent(ctx, builder);
+        (0, fs_extra_1.writeFileSync)(filePath, builder.toString());
+        return { typeName: builder.toString(), packageName };
+    }
+    generateApiControllerFileContent(ctx, builder) {
+        builder
+            .apply((builder) => this.generateApiControllerAnnotations(ctx, builder))
+            .ensureCurrentLineEmpty()
+            .apply((builder) => this.generateApiControllerSignature(ctx, builder))
+            .append(' ')
+            .parenthesize('{}', (builder) => builder
+            .appendLine()
+            .apply((builder) => this.generateApiControllerContent(ctx, builder))
+            .ensureCurrentLineEmpty());
+    }
+    generateApiControllerAnnotations(ctx, 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),
+        ]);
+    }
+    generateApiControllerSignature(ctx, builder) {
+        builder
+            .append('class ')
+            .append(this.getApiControllerName(ctx))
+            .parenthesize('()', (builder) => builder
+            .appendLine()
+            .apply((builder) => this.generateApiControllerParameters(ctx, builder))
+            .ensureCurrentLineEmpty())
+            .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
+            .appendLine()
+            .append('this.delegate = Optional.ofNullable(delegate).orElse')
+            .addImport('Optional', 'java.util')
+            .parenthesize('()', (builder) => builder.append('object : ').append(this.getApiDelegateInterfaceName(ctx)).append(' {}'))
+            .appendLine())
+            .appendLine()
+            .appendLine()
+            .appendLine(`override fun getDelegate(): ${this.getApiDelegateInterfaceName(ctx)} = delegate`);
+    }
+    generateApiDelegateInterfaceFile(ctx, dirPath, packageName) {
+        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_1.KotlinFileBuilder(packageName, ctx.config);
+        this.generateApiDelegateInterfaceFileContent(ctx, builder);
+        (0, fs_extra_1.writeFileSync)(filePath, builder.toString());
+        return { typeName: builder.toString(), packageName };
+    }
+    generateApiDelegateInterfaceFileContent(ctx, builder) {
+        builder
+            .apply((builder) => this.generateApiDelegateInterfaceAnnotations(ctx, builder))
+            .ensureCurrentLineEmpty()
+            .apply((builder) => this.generateApiDelegateInterfaceSignature(ctx, builder))
+            .append(' ')
+            .parenthesize('{}', (builder) => builder
+            .appendLine()
+            .apply((builder) => this.generateApiDelegateInterfaceContent(ctx, builder))
+            .ensureCurrentLineEmpty());
+    }
+    generateApiDelegateInterfaceAnnotations(ctx, builder) {
+        builder.appendAnnotation('Generated', 'jakarta.annotation', [
+            ['value', '[' + this.toStringLiteral(ctx, '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()
+            .apply((builder) => this.generateApiDelegateInterfaceMethod(ctx, builder, endpoint)));
+    }
+    generateApiDelegateInterfaceMethod(ctx, builder, endpoint) {
+        builder
+            .apply((builder) => this.generateApiDelegateInterfaceMethodAnnnotations(ctx, builder, endpoint))
+            .ensureCurrentLineEmpty()
+            .apply((builder) => this.generateApiDelegateInterfaceMethodSignature(ctx, builder, endpoint))
+            .append(' ')
+            .parenthesize('{}', (builder) => builder
+            .appendLine()
+            .apply((builder) => this.generateApiDelegateInterfaceMethodContent(ctx, builder, endpoint))
+            .ensureCurrentLineEmpty());
+    }
+    generateApiDelegateInterfaceMethodAnnnotations(ctx, builder, endpoint) {
+        // None for now.
+    }
+    generateApiDelegateInterfaceMethodSignature(ctx, builder, endpoint) {
+        builder
+            .append(`suspend fun ${(0, core_1.toCasing)(endpoint.name, 'camel')}`)
+            .parenthesize('()', (builder) => builder
+            .appendLine()
+            .apply((builder) => this.generateApiDelegateInterfaceMethodParameters(ctx, builder, endpoint))
+            .appendLine())
+            .append(': ')
+            .apply((builder) => this.generateApiDelegateInterfaceMethodReturnType(ctx, builder, endpoint));
+    }
+    generateApiDelegateInterfaceMethodParameters(ctx, builder, endpoint) {
+        const parameters = this.getAllParameters(ctx, endpoint);
+        builder.forEachSeparated(parameters, ',\n', (builder, parameter) => this.generateApiDelegateInterfaceMethodParameter(ctx, builder, endpoint, parameter));
+    }
+    generateApiDelegateInterfaceMethodReturnType(ctx, builder, endpoint) {
+        var _a, _b;
+        this.generateResponseEntityType(ctx, builder, (_b = (_a = endpoint.responses[0]) === null || _a === void 0 ? void 0 : _a.contentOptions[0]) === null || _b === void 0 ? void 0 : _b.schema);
+    }
+    generateApiDelegateInterfaceMethodParameter(ctx, builder, endpoint, parameter) {
+        builder
+            .apply((builder) => this.generateApiDelegateInterfaceMethodParameterAnnotations(ctx, builder, endpoint, parameter))
+            .ensureCurrentLineEmpty()
+            .apply((builder) => this.generateApiDelegateInterfaceMethodParameterSignature(ctx, builder, endpoint, parameter));
+    }
+    generateApiDelegateInterfaceMethodParameterAnnotations(ctx, builder, endpoint, parameter) {
+        // None for now.
+    }
+    generateApiDelegateInterfaceMethodParameterSignature(ctx, builder, endpoint, parameter) {
+        builder
+            .append((0, core_1.toCasing)(parameter.name, 'camel'))
+            .append(': ')
+            .apply((builder) => this.generateTypeUsage(ctx, builder, parameter.schema));
+    }
+    generateApiDelegateInterfaceMethodContent(ctx, builder, endpoint) {
+        builder
+            .appendLine('return ResponseEntity(HttpStatus.NOT_IMPLEMENTED)')
+            .addImport('ResponseEntity', 'org.springframework.http')
+            .addImport('HttpStatus', 'org.springframework.http');
+    }
+    generateResponseEntityType(ctx, builder, schema) {
+        builder
+            .append('ResponseEntity')
+            .addImport('ResponseEntity', 'org.springframework.http')
+            .parenthesize('<>', (builder) => this.generateTypeUsage(ctx, builder, schema, 'Unit'));
+    }
+    generateTypeUsage(ctx, builder, schema, fallback) {
+        if (schema && schema.kind === 'array') {
+            const schemaInfo = this.getSchemaInfo(ctx, schema.items);
+            builder.append(`Flux<${schemaInfo.typeName}>`).addImport('Flux', 'reactor.core.publisher');
+            builder.imports.addImports([schemaInfo, ...schemaInfo.additionalImports]);
+        }
+        else if (schema || !fallback) {
+            const schemaInfo = this.getSchemaInfo(ctx, schema);
+            builder.append(schemaInfo.typeName);
+            builder.imports.addImports([schemaInfo, ...schemaInfo.additionalImports]);
+        }
+        else {
+            builder.append(fallback);
+        }
+    }
+    getControllerRequestMapping(ctx, prefix) {
+        var _a, _b, _c, _d, _e, _f;
+        const basePath = (_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 : '/';
+        prefix !== null && prefix !== void 0 ? prefix : (prefix = `openapi.${(0, core_1.toCasing)(ctx.service.name, 'camel')}`);
+        return this.toStringLiteral(ctx, `\${${prefix}.base-path:${basePath}}`);
+    }
+    getDirectoryPath(ctx, packageName) {
+        return `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}`;
+    }
+    getPackageName(ctx) {
+        return ctx.config.packageName + ctx.config.packageSuffix;
+    }
+    getApiInterfaceName(ctx) {
+        return (0, core_1.toCasing)(ctx.service.name, 'pascal') + 'Api';
+    }
+    getApiControllerName(ctx) {
+        return (0, core_1.toCasing)(ctx.service.name, 'pascal') + 'ApiController';
+    }
+    getApiDelegateInterfaceName(ctx) {
+        return (0, core_1.toCasing)(ctx.service.name, 'pascal') + 'ApiDelegate';
+    }
+    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) {
+        const parameters = endpoint.parameters.filter((parameter) => parameter.target === 'query' || parameter.target === 'path');
+        if (endpoint.requestBody) {
+            const schema = endpoint.requestBody.content[0].schema;
+            parameters.push({
+                $src: undefined,
+                $ref: undefined,
+                id: 'body',
+                name: schema ? this.getSchemaInfo(ctx, schema).typeName : 'body',
+                target: 'body',
+                schema,
+                required: endpoint.requestBody.required,
+                description: endpoint.requestBody.description,
+                allowEmptyValue: undefined,
+                allowReserved: undefined,
+                deprecated: false,
+                explode: undefined,
+                style: undefined,
+            });
+        }
+        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;
+        });
+    }
+}
+exports.DefaultKotlinSpringControllerGenerator = DefaultKotlinSpringControllerGenerator;

package/cjs/lib/generators/services/spring-controllers/spring-controllers-generator.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KotlinSpringControllersGenerator = void 0;
+const core_1 = require("@goast/core");
+const models_1 = require("./models");
+const spring_controller_generator_1 = require("./spring-controller-generator");
+class KotlinSpringControllersGenerator extends core_1.OpenApiServicesGenerationProviderBase {
+    constructor(serviceGeneratorFactory) {
+        super();
+        this._serviceGeneratorFactory =
+            serviceGeneratorFactory !== null && serviceGeneratorFactory !== void 0 ? serviceGeneratorFactory : core_1.Factory.fromValue(new spring_controller_generator_1.DefaultKotlinSpringControllerGenerator());
+    }
+    initResult() {
+        return {
+            services: {},
+        };
+    }
+    generateService(ctx, service) {
+        const serviceGenerator = this._serviceGeneratorFactory.create();
+        return serviceGenerator.generate(Object.assign(Object.assign({}, ctx), { service }));
+    }
+    addServiceResult(ctx, service, result) {
+        ctx.output.services[service.id] = result;
+    }
+    buildContext(context, config) {
+        context.data.services = context.data.services.filter((x) => x.name !== 'exclude-from-generation');
+        return this.getProviderContext(context, config, models_1.defaultKotlinServicesGeneratorConfig);
+    }
+}
+exports.KotlinSpringControllersGenerator = KotlinSpringControllersGenerator;

package/cjs/lib/import-collection.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportCollection = void 0;
+const core_1 = require("@goast/core");
+class ImportCollection {
+    constructor() {
+        this._imports = new Map();
+    }
+    get hasImports() {
+        return this._imports.size > 0;
+    }
+    get imports() {
+        return Array.from(this._imports.entries())
+            .map(([fromPackage, importNames]) => Array.from(importNames).map((importName) => ({
+            packageName: fromPackage,
+            typeName: importName,
+        })))
+            .flat();
+    }
+    addImport(importOrImportName, fromModule) {
+        const importName = typeof importOrImportName === 'string' ? importOrImportName : importOrImportName.typeName;
+        fromModule = typeof importOrImportName === 'string' ? fromModule : importOrImportName.packageName;
+        if (!fromModule) {
+            return;
+        }
+        const existingImport = this._imports.get(fromModule);
+        if (existingImport) {
+            existingImport.add(importName);
+        }
+        else {
+            this._imports.set(fromModule, new Set([importName]));
+        }
+    }
+    addImports(imports) {
+        for (const importObj of imports) {
+            this.addImport(importObj);
+        }
+    }
+    clear() {
+        this._imports.clear();
+    }
+    toString(options) {
+        const builder = new core_1.StringBuilder(options);
+        this.writeTo(builder);
+        return builder.toString();
+    }
+    writeTo(builder) {
+        if (this._imports.size > 0) {
+            const sortedImports = Array.from(this._imports.entries()).sort(([fromModuleA], [fromModuleB]) => {
+                if (isCoreImport(fromModuleA) && !isCoreImport(fromModuleB)) {
+                    return 1;
+                }
+                else if (!isCoreImport(fromModuleA) && isCoreImport(fromModuleB)) {
+                    return -1;
+                }
+                return fromModuleA.localeCompare(fromModuleB);
+            });
+            for (const [fromPackage, importNames] of sortedImports) {
+                const sortedImportNames = Array.from(importNames).sort();
+                for (const importName of sortedImportNames) {
+                    builder.appendLine(`import ${fromPackage}.${importName}`);
+                }
+            }
+        }
+    }
+}
+exports.ImportCollection = ImportCollection;
+function isCoreImport(packageName) {
+    return packageName.startsWith('kotlin.') || packageName.startsWith('java.') || packageName.startsWith('javax.');
+}

package/cjs/lib/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKotlinPropertyName = exports.toKotlinStringLiteral = void 0;
+function toKotlinStringLiteral(value) {
+    if (!value) {
+        return '""';
+    }
+    const escaped = value
+        .replace(/(["\\$])/g, '\\$1')
+        .replace(/\n/g, '\\n')
+        .replace(/\r/g, '\\r')
+        .replace(/\t/g, '\\t');
+    return `"${escaped}"`;
+}
+exports.toKotlinStringLiteral = toKotlinStringLiteral;
+function toKotlinPropertyName(value) {
+    if (value.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*$/)) {
+        return value;
+    }
+    return `\`${value}\``;
+}
+exports.toKotlinPropertyName = toKotlinPropertyName;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/esm/index.js

@@ -0,0 +1,6 @@
+export * from './lib/common-results';
+export * from './lib/config';
+export * from './lib/generators';
+export * from './lib/file-builder';
+export * from './lib/import-collection';
+export * from './lib/utils';

package/esm/lib/common-results.js

@@ -0,0 +1 @@
+export {};

package/esm/lib/config.js

@@ -0,0 +1,6 @@
+export const defaultKotlinGeneratorConfig = {
+    charsTreatedAsEmptyLine: ['{'],
+    indent: { type: 'spaces', count: 4 },
+    propertyNameCasing: 'camel',
+    enumValueNameCasing: 'snake',
+};

package/esm/lib/file-builder.js

@@ -0,0 +1,59 @@
+import { SourceBuilder } from '@goast/core';
+import { ImportCollection } from './import-collection';
+export class KotlinFileBuilder extends SourceBuilder {
+    constructor(packageName, options) {
+        super(options);
+        this.imports = new ImportCollection();
+        this.packageName = packageName;
+    }
+    addImport(name, packageName) {
+        if (packageName !== undefined && packageName !== this.packageName) {
+            this.imports.addImport(name, packageName);
+        }
+        return this;
+    }
+    appendAnnotation(name, packageName, args) {
+        const allArgs = [];
+        if (args) {
+            for (const a of args) {
+                if (!Array.isArray(a)) {
+                    allArgs.push([undefined, a]);
+                }
+                else if (a.length === 2 && a[1] === true) {
+                    allArgs.push([undefined, a[0]]);
+                }
+            }
+            for (const a of args) {
+                if (Array.isArray(a) && typeof a[1] !== 'boolean' && a[2] !== false) {
+                    allArgs.push(a.length === 2 ? a : [a[0], a[1]]);
+                }
+            }
+        }
+        this.append(`@${name}`).addImport(name, packageName);
+        if (allArgs.length > 0) {
+            const multiline = allArgs.some((x) => typeof x[1] !== 'string') ||
+                allArgs.reduce((c, [key, value]) => { var _a; return c + (key ? key.length + 3 : 0) + ((_a = value === null || value === void 0 ? void 0 : value.length) !== null && _a !== void 0 ? _a : 0); }, 0) > 80;
+            this.parenthesize('()', (builder) => builder
+                .appendLineIf(multiline)
+                .forEachSeparated(allArgs, multiline ? ',\n' : ', ', (builder, [name, value]) => builder
+                .append(name ? `${name} = ` : '')
+                .apply((builder) => (typeof value === 'string' ? builder.append(value) : value(builder))))
+                .appendLineIf(multiline));
+        }
+        this.appendLine();
+        return this;
+    }
+    clear() {
+        super.clear();
+        this.imports.clear();
+    }
+    toString(addPadding = true) {
+        return new SourceBuilder(this.options)
+            .applyIf(this.packageName !== undefined, (builder) => builder.appendLine(`package ${this.packageName}`).appendLine())
+            .apply((builder) => this.imports.writeTo(builder))
+            .applyIf(addPadding, (builder) => builder.ensurePreviousLineEmpty())
+            .append(super.toString())
+            .applyIf(addPadding, (builder) => builder.ensureCurrentLineEmpty())
+            .toString();
+    }
+}

package/esm/lib/generators/file-generator.js

@@ -0,0 +1,13 @@
+import { toCasing } from '@goast/core';
+import { toKotlinPropertyName, toKotlinStringLiteral } from '../utils';
+export class KotlinFileGenerator {
+    toPropertyName(context, name) {
+        return toKotlinPropertyName(toCasing(name, context.config.propertyNameCasing));
+    }
+    toEnumValueName(context, name) {
+        return toKotlinPropertyName(toCasing(name, context.config.enumValueNameCasing));
+    }
+    toStringLiteral(context, text) {
+        return toKotlinStringLiteral(text);
+    }
+}

package/esm/lib/generators/index.js

@@ -0,0 +1,3 @@
+export * from './file-generator';
+export * from './models';
+export * from './services/spring-controllers';

package/esm/lib/generators/models/index.js

@@ -0,0 +1,3 @@
+export * from './model-generator';
+export * from './models';
+export * from './models-generator';