@goast/kotlin 0.0.1

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

@@ -0,0 +1,412 @@
+import { ensureDirSync, writeFileSync } from 'fs-extra';
+import { toCasing } from '@goast/core';
+import { KotlinFileBuilder } from '../../../file-builder';
+import { KotlinFileGenerator } from '../../file-generator';
+export class DefaultKotlinSpringControllerGenerator extends KotlinFileGenerator {
+    generate(ctx) {
+        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),
+        };
+    }
+    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 KotlinFileBuilder(packageName, ctx.config);
+        this.generateApiInterfaceFileContent(ctx, builder);
+        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 ${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(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().${toCasing(endpoint.name, 'camel')}(`)
+            .forEachSeparated(parameters, ', ', (builder, parameter) => builder.append(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 KotlinFileBuilder(packageName, ctx.config);
+        this.generateApiControllerFileContent(ctx, builder);
+        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 KotlinFileBuilder(packageName, ctx.config);
+        this.generateApiDelegateInterfaceFileContent(ctx, builder);
+        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 ${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(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.${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 toCasing(ctx.service.name, 'pascal') + 'Api';
+    }
+    getApiControllerName(ctx) {
+        return toCasing(ctx.service.name, 'pascal') + 'ApiController';
+    }
+    getApiDelegateInterfaceName(ctx) {
+        return 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;
+        });
+    }
+}

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

@@ -0,0 +1,26 @@
+import { Factory, OpenApiServicesGenerationProviderBase } from '@goast/core';
+import { defaultKotlinServicesGeneratorConfig, } from './models';
+import { DefaultKotlinSpringControllerGenerator } from './spring-controller-generator';
+export class KotlinSpringControllersGenerator extends OpenApiServicesGenerationProviderBase {
+    constructor(serviceGeneratorFactory) {
+        super();
+        this._serviceGeneratorFactory =
+            serviceGeneratorFactory !== null && serviceGeneratorFactory !== void 0 ? serviceGeneratorFactory : Factory.fromValue(new 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, defaultKotlinServicesGeneratorConfig);
+    }
+}

package/esm/lib/import-collection.js

@@ -0,0 +1,66 @@
+import { StringBuilder } from '@goast/core';
+export 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 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}`);
+                }
+            }
+        }
+    }
+}
+function isCoreImport(packageName) {
+    return packageName.startsWith('kotlin.') || packageName.startsWith('java.') || packageName.startsWith('javax.');
+}

package/esm/lib/utils.js

@@ -0,0 +1,17 @@
+export 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}"`;
+}
+export function toKotlinPropertyName(value) {
+    if (value.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*$/)) {
+        return value;
+    }
+    return `\`${value}\``;
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@goast/kotlin",
+  "version": "0.0.1",
+  "repository": "https://github.com/MaSch0212/goast.git",
+  "author": {
+    "name": "Marc Schmidt (MaSch0212)",
+    "url": "https://github.com/MaSch0212"
+  },
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "fs-extra": "^11.1.1",
+    "node-fetch": "^2.6.11",
+    "yaml": "^2.3.1",
+    "@goast/core": "0.0.5",
+    "tslib": "^2.3.0"
+  },
+  "module": "./esm/index.js",
+  "main": "./cjs/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./cjs/index.js",
+      "types": "./types/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/types/index.d.ts

@@ -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/types/lib/common-results.d.ts

@@ -0,0 +1,4 @@
+export type KotlinImport = {
+    packageName?: string;
+    typeName: string;
+};

package/types/lib/config.d.ts

@@ -0,0 +1,6 @@
+import { DefaultGenerationProviderConfig, OpenApiGeneratorConfig, StringCasing, StringCasingWithOptions } from '@goast/core';
+export type KotlinGeneratorConfig = OpenApiGeneratorConfig & {
+    propertyNameCasing: StringCasing | StringCasingWithOptions;
+    enumValueNameCasing: StringCasing | StringCasingWithOptions;
+};
+export declare const defaultKotlinGeneratorConfig: DefaultGenerationProviderConfig<KotlinGeneratorConfig>;

package/types/lib/file-builder.d.ts

@@ -0,0 +1,14 @@
+import { SourceBuilder, SourceBuilderOptions } from '@goast/core';
+import { ImportCollection } from './import-collection';
+type AnnotationArgumentValue<T extends SourceBuilder> = string | ((builder: T) => void);
+type AnnotationArgument<T extends SourceBuilder> = AnnotationArgumentValue<T> | [key: string, value: AnnotationArgumentValue<T>] | [value: AnnotationArgumentValue<T>, condition: boolean] | [key: string, value: AnnotationArgumentValue<T>, condition: boolean];
+export declare class KotlinFileBuilder extends SourceBuilder {
+    readonly packageName: string | undefined;
+    readonly imports: ImportCollection;
+    constructor(packageName: string | undefined, options: SourceBuilderOptions);
+    addImport(name: string, packageName?: string): this;
+    appendAnnotation(name: string, packageName: string | undefined, args?: AnnotationArgument<this>[]): this;
+    clear(): void;
+    toString(addPadding?: boolean): string;
+}
+export {};

package/types/lib/generators/file-generator.d.ts

@@ -0,0 +1,8 @@
+import { Nullable, OpenApiGenerationProviderContext, OpenApiGeneratorInput } from '@goast/core';
+import { KotlinGeneratorConfig } from '../config';
+export declare abstract class KotlinFileGenerator<TContext extends OpenApiGenerationProviderContext<OpenApiGeneratorInput, KotlinGeneratorConfig>, TOutput> {
+    abstract generate(context: TContext): TOutput;
+    protected toPropertyName(context: TContext, name: string): string;
+    protected toEnumValueName(context: TContext, name: string): string;
+    protected toStringLiteral(context: TContext, text: Nullable<string>): string;
+}

package/types/lib/generators/index.d.ts

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

package/types/lib/generators/models/index.d.ts

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

package/types/lib/generators/models/model-generator.d.ts

@@ -0,0 +1,31 @@
+import { ApiSchema, ApiSchemaProperty } from '@goast/core';
+import { KotlinModelGeneratorContext, KotlinModelGeneratorOutput } from './models';
+import { KotlinFileBuilder } from '../../file-builder';
+import { KotlinFileGenerator } from '../file-generator';
+type Context = KotlinModelGeneratorContext;
+type Output = KotlinModelGeneratorOutput;
+type Builder = KotlinFileBuilder;
+export interface KotlinModelGenerator<TOutput extends Output = Output> {
+    generate(ctx: Context): TOutput;
+}
+export declare class DefaultKotlinModelGenerator extends KotlinFileGenerator<Context, Output> implements KotlinModelGenerator {
+    generate(ctx: KotlinModelGeneratorContext): KotlinModelGeneratorOutput;
+    protected generateFileContent(ctx: Context, builder: Builder): void;
+    protected generateObjectType(ctx: Context, builder: Builder, schema: ApiSchema<'object'>): void;
+    protected generateDataClass(ctx: Context, builder: Builder, schema: ApiSchema<'object'>): void;
+    protected generatePropertyAnnotations(ctx: Context, builder: Builder, schema: ApiSchema, property: ApiSchemaProperty): void;
+    protected generatePropertyValidationAnnotations(ctx: Context, builder: Builder, schema: ApiSchema, property: ApiSchemaProperty): void;
+    protected generatePropertySchemaAnnotation(ctx: Context, builder: Builder, schema: ApiSchema, property: ApiSchemaProperty): void;
+    protected generateJsonPropertyAnnotation(ctx: Context, builder: Builder, schema: ApiSchema, property: ApiSchemaProperty): void;
+    protected generateMapType(ctx: Context, builder: Builder, schema: ApiSchema<'object'>): void;
+    protected generateType(ctx: Context, builder: Builder, schema: ApiSchema): void;
+    protected generateNumberType(ctx: Context, builder: Builder, schema: ApiSchema<'number' | 'integer'>): void;
+    protected generateStringType(ctx: Context, builder: Builder, schema: ApiSchema<'string'>): void;
+    protected generateEnum(ctx: Context, builder: Builder, schema: ApiSchema): void;
+    protected generateArrayType(ctx: Context, builder: Builder, schema: ApiSchema<'array'>): void;
+    protected generateDocumentation(ctx: Context, builder: Builder, schema: ApiSchema): void;
+    protected shouldGenerateTypeDeclaration(ctx: Context, schema: ApiSchema): boolean;
+    protected getDeclarationTypeName(ctx: Context): string;
+    protected sortProperties(ctx: Context, schema: ApiSchema, properties: Iterable<ApiSchemaProperty>): ApiSchemaProperty[];
+}
+export {};

package/types/lib/generators/models/models-generator.d.ts

@@ -0,0 +1,17 @@
+import { ApiSchema, Factory, OpenApiGeneratorContext, OpenApiSchemasGenerationProviderBase } from '@goast/core';
+import { KotlinModelGenerator } from './model-generator';
+import { KotlinModelsGeneratorInput, KotlinModelsGeneratorOutput, KotlinModelsGeneratorConfig, KotlinModelGeneratorOutput, KotlinModelsGeneratorContext } from './models';
+type Input = KotlinModelsGeneratorInput;
+type Output = KotlinModelsGeneratorOutput;
+type Config = KotlinModelsGeneratorConfig;
+type SchemaOutput = KotlinModelGeneratorOutput;
+type Context = KotlinModelsGeneratorContext;
+export declare class KotlinModelsGenerator extends OpenApiSchemasGenerationProviderBase<Input, Output, Config, SchemaOutput, Context> {
+    private readonly _modelGeneratorFactory;
+    constructor(modelGeneratorFactory?: Factory<KotlinModelGenerator, []>);
+    protected initResult(): Output;
+    protected buildContext(context: OpenApiGeneratorContext<KotlinModelsGeneratorInput>, config?: Partial<Config> | undefined): Context;
+    protected generateSchema(ctx: Context, schema: ApiSchema): SchemaOutput;
+    protected addSchemaResult(ctx: Context, schema: ApiSchema, result: SchemaOutput): void;
+}
+export {};