@goast/kotlin 0.0.1

package/README.md

@@ -0,0 +1,7 @@
+# kotlin
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test kotlin` to execute the unit tests via [Jest](https://jestjs.io).

package/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib/common-results"), exports);
+tslib_1.__exportStar(require("./lib/config"), exports);
+tslib_1.__exportStar(require("./lib/generators"), exports);
+tslib_1.__exportStar(require("./lib/file-builder"), exports);
+tslib_1.__exportStar(require("./lib/import-collection"), exports);
+tslib_1.__exportStar(require("./lib/utils"), exports);

package/cjs/lib/common-results.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/lib/config.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultKotlinGeneratorConfig = void 0;
+exports.defaultKotlinGeneratorConfig = {
+    charsTreatedAsEmptyLine: ['{'],
+    indent: { type: 'spaces', count: 4 },
+    propertyNameCasing: 'camel',
+    enumValueNameCasing: 'snake',
+};

package/cjs/lib/file-builder.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KotlinFileBuilder = void 0;
+const core_1 = require("@goast/core");
+const import_collection_1 = require("./import-collection");
+class KotlinFileBuilder extends core_1.SourceBuilder {
+    constructor(packageName, options) {
+        super(options);
+        this.imports = new import_collection_1.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 core_1.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();
+    }
+}
+exports.KotlinFileBuilder = KotlinFileBuilder;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KotlinFileGenerator = void 0;
+const core_1 = require("@goast/core");
+const utils_1 = require("../utils");
+class KotlinFileGenerator {
+    toPropertyName(context, name) {
+        return (0, utils_1.toKotlinPropertyName)((0, core_1.toCasing)(name, context.config.propertyNameCasing));
+    }
+    toEnumValueName(context, name) {
+        return (0, utils_1.toKotlinPropertyName)((0, core_1.toCasing)(name, context.config.enumValueNameCasing));
+    }
+    toStringLiteral(context, text) {
+        return (0, utils_1.toKotlinStringLiteral)(text);
+    }
+}
+exports.KotlinFileGenerator = KotlinFileGenerator;

package/cjs/lib/generators/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./file-generator"), exports);
+tslib_1.__exportStar(require("./models"), exports);
+tslib_1.__exportStar(require("./services/spring-controllers"), exports);

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./model-generator"), exports);
+tslib_1.__exportStar(require("./models"), exports);
+tslib_1.__exportStar(require("./models-generator"), exports);

package/cjs/lib/generators/models/model-generator.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultKotlinModelGenerator = void 0;
+const path_1 = require("path");
+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 DefaultKotlinModelGenerator extends file_generator_1.KotlinFileGenerator {
+    generate(ctx) {
+        if (/\/(anyOf|allOf)(\/[0-9]+)?$/.test(ctx.schema.$src.path)) {
+            // Do not generate types that are only used for anyOf and/or allOf
+            return { typeName: 'Any?', packageName: undefined, additionalImports: [] };
+        }
+        if (ctx.schema.id === ctx.schema.name) {
+            // TODO: Add this to @goast/core
+            const match = ctx.schema.$src.path.match(/\/components\/responses\/([^/]+)\/content\/.+\/schema/);
+            if (match) {
+                ctx.schema.name = match[1].toLowerCase().endsWith('response') ? match[1] : match[1] + 'Response';
+            }
+        }
+        if (ctx.schema.isNameGenerated) {
+            // TODO: Change this in @goast/core
+            const match = ctx.schema.$src.path.match(/\/paths\/(?<path>.+)\/(?<method>.+)\/responses\/(?<status>\d+)\//);
+            if (match && match.groups) {
+                const { path, method, status } = match.groups;
+                const endpoint = ctx.data.endpoints.find((e) => e.path === path && e.method === method);
+                if (endpoint) {
+                    ctx.schema.name = `${endpoint.name}${status}Response`;
+                }
+            }
+        }
+        if (this.shouldGenerateTypeDeclaration(ctx, ctx.schema)) {
+            const typeName = this.getDeclarationTypeName(ctx);
+            const packageName = ctx.config.packageName + ctx.config.packageSuffix;
+            const filePath = `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}/${typeName}.kt`;
+            console.log(`Generating model ${packageName}.${typeName} to ${filePath}...`);
+            (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(filePath));
+            const builder = new file_builder_1.KotlinFileBuilder(packageName, ctx.config);
+            this.generateFileContent(ctx, builder);
+            (0, fs_extra_1.writeFileSync)(filePath, builder.toString());
+            return { typeName, packageName, additionalImports: [] };
+        }
+        else {
+            const builder = new file_builder_1.KotlinFileBuilder(undefined, ctx.config);
+            this.generateType(ctx, builder, ctx.schema);
+            const additionalImports = builder.imports.imports;
+            builder.imports.clear();
+            return { typeName: builder.toString(false), packageName: undefined, additionalImports };
+        }
+    }
+    generateFileContent(ctx, builder) {
+        let schema = ctx.schema;
+        if (schema.kind === 'object' || schema.kind === 'combined') {
+            const mergedSchema = (0, core_1.resolveAnyOfAndAllOf)(schema, true);
+            if (mergedSchema) {
+                schema = mergedSchema;
+            }
+        }
+        if (schema.kind === 'object') {
+            this.generateObjectType(ctx, builder, schema);
+        }
+        else if (schema.enum !== undefined && schema.enum.length > 0) {
+            this.generateEnum(ctx, builder, schema);
+        }
+        else {
+            this.generateType(ctx, builder, schema);
+        }
+    }
+    generateObjectType(ctx, builder, schema) {
+        if (schema.properties.size === 0) {
+            if (schema.additionalProperties) {
+                this.generateMapType(ctx, builder, schema);
+            }
+            else {
+                builder.append('Any');
+            }
+        }
+        else {
+            this.generateDataClass(ctx, builder, schema);
+        }
+    }
+    generateDataClass(ctx, builder, schema) {
+        builder
+            .apply((builder) => this.generateDocumentation(ctx, builder, schema))
+            .append('data class ')
+            .append(this.getDeclarationTypeName(ctx))
+            .parenthesizeIf(schema.properties.size > 0, '()', (builder) => builder
+            .appendLine()
+            .forEachSeparated(this.sortProperties(ctx, schema, schema.properties.values()), ',\n', (builder, property) => builder
+            .ensurePreviousLineEmpty()
+            .apply((builder) => this.generatePropertyAnnotations(ctx, builder, schema, property))
+            .append(`val ${(0, core_1.toCasing)(property.name, 'camel')}: `)
+            .apply((builder) => this.generateType(ctx, builder, property.schema))
+            .applyIf(!schema.required.has(property.name), (builder) => builder.appendIf(!property.schema.nullable, '?').append(' = null')))
+            .appendLineIf(schema.properties.size > 0))
+            .parenthesizeIf(schema.additionalProperties !== undefined && schema.additionalProperties !== false, '{}', (builder) => builder
+            .appendLine()
+            .applyIf(schema.additionalProperties !== undefined && schema.additionalProperties !== false, (builder) => builder
+            .appendLine('@JsonIgnore')
+            .addImport('JsonIgnore', 'com.fasterxml.jackson.annotation')
+            .append('val additionalProperties: Mutable')
+            .apply((builder) => this.generateMapType(ctx, builder, schema))
+            .appendLine(' = mutableMapOf()')
+            .appendLine()
+            .appendLine('@JsonAnySetter')
+            .addImport('JsonAnySetter', 'com.fasterxml.jackson.annotation')
+            .append('fun set')
+            .parenthesize('()', (builder) => builder.append('name: String, value: ').applyIfElse(schema.additionalProperties === true, (builder) => builder.append('Any?'), (builder) => this.generateType(ctx, builder, schema.additionalProperties)))
+            .append(' ')
+            .parenthesize('{}', (builder) => builder.appendLine().appendLine('this.additionalProperties[name] = value'))
+            .appendLine()
+            .appendLine()
+            .appendLine('@JsonAnyGetter')
+            .addImport('JsonAnyGetter', 'com.fasterxml.jackson.annotation')
+            .append('fun getMap(): ')
+            .apply((builder) => this.generateMapType(ctx, builder, schema))
+            .append(' ')
+            .parenthesize('{}', (builder) => builder.appendLine().appendLine('return this.additionalProperties'))
+            .appendLine()));
+    }
+    generatePropertyAnnotations(ctx, builder, schema, property) {
+        this.generatePropertyValidationAnnotations(ctx, builder, schema, property);
+        this.generatePropertySchemaAnnotation(ctx, builder, schema, property);
+        this.generateJsonPropertyAnnotation(ctx, builder, schema, property);
+    }
+    generatePropertyValidationAnnotations(ctx, builder, schema, property) {
+        if (property.schema.kind === 'string' && property.schema.pattern) {
+            builder
+                .append('@get:Pattern(regexp = ')
+                .append(this.toStringLiteral(ctx, property.schema.pattern))
+                .append(')')
+                .addImport('Pattern', 'jakarta.validation.constraints')
+                .appendLine();
+        }
+        if (this.shouldGenerateTypeDeclaration(ctx, property.schema)) {
+            builder.append('@field:Valid').addImport('Valid', 'jakarta.validation').appendLine();
+        }
+    }
+    generatePropertySchemaAnnotation(ctx, builder, schema, property) {
+        const parts = new Map();
+        if (property.schema.example !== undefined) {
+            parts.set('example', this.toStringLiteral(ctx, String(property.schema.example)));
+        }
+        if (schema.required.has(property.name)) {
+            parts.set('required', 'true');
+        }
+        if (property.schema.description !== undefined) {
+            parts.set('description', this.toStringLiteral(ctx, property.schema.description));
+        }
+        builder
+            .append('@Schema')
+            .addImport('Schema', 'io.swagger.v3.oas.annotations.media')
+            .parenthesizeIf(parts.size > 0, '()', (builder) => builder.forEachSeparated(parts.entries(), ', ', (builder, [key, value]) => builder.append(`${key} = ${value}`)))
+            .appendLine();
+    }
+    generateJsonPropertyAnnotation(ctx, builder, schema, property) {
+        builder
+            .append('@JsonProperty')
+            .addImport('JsonProperty', 'com.fasterxml.jackson.annotation')
+            .parenthesize('()', (builder) => builder
+            .append(this.toStringLiteral(ctx, property.name))
+            .appendIf(schema.required.has(property.name), ', required = true'))
+            .appendLine()
+            .applyIf(property.schema.custom['exclude-when-null'] === true, (builder) => builder
+            .append('@get:JsonInclude')
+            .addImport('JsonInclude', 'com.fasterxml.jackson.annotation')
+            .parenthesize('()', (builder) => builder.append('JsonInclude.Include.NON_NULL'))
+            .appendLine());
+    }
+    generateMapType(ctx, builder, schema) {
+        if (schema.additionalProperties === true) {
+            builder.append('Map<String, Any?>');
+        }
+        else if (typeof schema.additionalProperties === 'object') {
+            const propertiesType = schema.additionalProperties;
+            builder
+                .append('Map')
+                .parenthesize('<>', (builder) => builder.append('String, ').apply((builder) => this.generateType(ctx, builder, propertiesType)));
+        }
+    }
+    generateType(ctx, builder, schema) {
+        if (this.shouldGenerateTypeDeclaration(ctx, schema)) {
+            if (schema === ctx.schema) {
+                builder.append('Any?');
+                return;
+            }
+            const schemaResult = ctx.getSchemaResult(schema);
+            builder.append(schemaResult.typeName);
+            if (schemaResult.packageName) {
+                builder.addImport(schemaResult.typeName, schemaResult.packageName);
+            }
+            return;
+        }
+        switch (schema.kind) {
+            case 'boolean':
+                builder.append('Boolean');
+                break;
+            case 'integer':
+            case 'number':
+                this.generateNumberType(ctx, builder, schema);
+                break;
+            case 'string':
+                if (schema.enum !== undefined && schema.enum.length > 0) {
+                    this.generateEnum(ctx, builder, schema);
+                }
+                else {
+                    this.generateStringType(ctx, builder, schema);
+                }
+                break;
+            case 'null':
+                builder.append('null');
+                break;
+            case 'unknown':
+                builder.append('Any');
+                break;
+            case 'array':
+                this.generateArrayType(ctx, builder, schema);
+                break;
+            case 'object':
+                this.generateObjectType(ctx, builder, schema);
+                break;
+            case 'combined':
+                builder.append('Any');
+                break;
+            case 'multi-type':
+                builder.append('Any');
+                break;
+            case 'oneOf':
+                builder.append('Any');
+                break;
+            default:
+                builder.append('Any');
+                break;
+        }
+        if (schema.nullable) {
+            builder.append('?');
+        }
+    }
+    generateNumberType(ctx, builder, schema) {
+        switch (schema.format) {
+            case 'int32':
+                builder.append('Int');
+                break;
+            case 'int64':
+                builder.append('Long');
+                break;
+            case 'float':
+                builder.append('Float');
+                break;
+            case 'double':
+                builder.append('Double');
+                break;
+            default:
+                builder.append(schema.kind === 'integer' ? 'Int' : 'Double');
+                break;
+        }
+    }
+    generateStringType(ctx, builder, schema) {
+        switch (schema.format) {
+            case 'date-time':
+                builder.append('OffsetDateTime').addImport('OffsetDateTime', 'java.time');
+                break;
+            default:
+                builder.append('String');
+                break;
+        }
+    }
+    generateEnum(ctx, builder, schema) {
+        builder
+            .apply((builder) => this.generateDocumentation(ctx, builder, schema))
+            .append('enum class ')
+            .append(this.getDeclarationTypeName(ctx))
+            .append('(val value: String) ')
+            .parenthesize('{}', (builder) => {
+            var _a;
+            return builder
+                .appendLine()
+                .forEachSeparated((_a = schema.enum) !== null && _a !== void 0 ? _a : [], (builder) => builder.appendLine(',').appendLine(), (builder, value) => builder
+                .append('@JsonProperty')
+                .addImport('JsonProperty', 'com.fasterxml.jackson.annotation')
+                .parenthesize('()', (builder) => builder.append(this.toStringLiteral(ctx, String(value))))
+                .appendLine()
+                .append((0, core_1.toCasing)(String(value), 'snake'))
+                .parenthesize('()', (builder) => builder.append(this.toStringLiteral(ctx, String(value)))))
+                .appendLine();
+        });
+    }
+    generateArrayType(ctx, builder, schema) {
+        builder.append('List').parenthesize('<>', (builder) => builder.applyIfElse(schema.items === undefined, (builder) => builder.append('Any?'), (builder) => this.generateType(ctx, builder, schema.items)));
+    }
+    generateDocumentation(ctx, builder, schema) {
+        var _a, _b;
+        const propertiesWithDescription = Array.from((_b = (_a = schema.properties) === null || _a === void 0 ? void 0 : _a.values()) !== null && _b !== void 0 ? _b : []).filter((p) => p.schema.description !== undefined);
+        if (schema.description !== undefined || propertiesWithDescription.length > 0) {
+            builder
+                .ensurePreviousLineEmpty()
+                .appendLine('/**')
+                .applyWithLinePrefix(' * ', (builder) => builder
+                .appendLineIf(!!schema.description, schema.description)
+                .forEach(propertiesWithDescription, (builder, property) => { var _a; return builder.appendLine(`@param ${(0, core_1.toCasing)(property.name, 'camel')} ${(_a = property.schema.description) === null || _a === void 0 ? void 0 : _a.trim()}`); }))
+                .appendLine(' */');
+        }
+    }
+    shouldGenerateTypeDeclaration(ctx, schema) {
+        // All enum types should have its own type declaration
+        if (schema.enum !== undefined && schema.enum.length > 0) {
+            return true;
+        }
+        // All primitive types already exist and do not need its own type declaration
+        if (schema.kind !== 'combined' &&
+            schema.kind !== 'multi-type' &&
+            schema.kind !== 'object' &&
+            schema.kind !== 'oneOf') {
+            return false;
+        }
+        // Only object types with properties should have its own type declaration
+        if (schema.kind === 'object' &&
+            schema.properties.size === 0 &&
+            schema.anyOf.length === 0 &&
+            schema.allOf.length === 0) {
+            return false;
+        }
+        return true;
+    }
+    getDeclarationTypeName(ctx) {
+        return (0, core_1.toCasing)(ctx.schema.name, 'pascal');
+    }
+    sortProperties(ctx, schema, properties) {
+        return [...properties].sort((a, b) => {
+            const aRequired = schema.required.has(a.name) ? 1 : 0;
+            const bRequired = schema.required.has(b.name) ? 1 : 0;
+            return bRequired - aRequired;
+        });
+    }
+}
+exports.DefaultKotlinModelGenerator = DefaultKotlinModelGenerator;

package/cjs/lib/generators/models/models-generator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KotlinModelsGenerator = void 0;
+const core_1 = require("@goast/core");
+const model_generator_1 = require("./model-generator");
+const models_1 = require("./models");
+class KotlinModelsGenerator extends core_1.OpenApiSchemasGenerationProviderBase {
+    constructor(modelGeneratorFactory) {
+        super();
+        this._modelGeneratorFactory = modelGeneratorFactory !== null && modelGeneratorFactory !== void 0 ? modelGeneratorFactory : core_1.Factory.fromValue(new model_generator_1.DefaultKotlinModelGenerator());
+    }
+    initResult() {
+        return {
+            models: {},
+        };
+    }
+    buildContext(context, config) {
+        return this.getProviderContext(context, config, models_1.defaultKotlinModelsGeneratorConfig);
+    }
+    generateSchema(ctx, schema) {
+        const modelGenerator = this._modelGeneratorFactory.create();
+        return modelGenerator.generate(Object.assign(Object.assign({}, ctx), { schema, getSchemaResult: (schema) => this.getSchemaResult(ctx, schema) }));
+    }
+    addSchemaResult(ctx, schema, result) {
+        ctx.output.models[schema.id] = result;
+    }
+}
+exports.KotlinModelsGenerator = KotlinModelsGenerator;

package/cjs/lib/generators/models/models.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultKotlinModelsGeneratorConfig = void 0;
+const config_1 = require("../../config");
+exports.defaultKotlinModelsGeneratorConfig = Object.assign(Object.assign({}, config_1.defaultKotlinGeneratorConfig), { packageName: 'com.openapi.generated', packageSuffix: '.model' });

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./models"), exports);
+tslib_1.__exportStar(require("./spring-controller-generator"), exports);
+tslib_1.__exportStar(require("./spring-controllers-generator"), exports);

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultKotlinServicesGeneratorConfig = void 0;
+const config_1 = require("../../../config");
+exports.defaultKotlinServicesGeneratorConfig = Object.assign(Object.assign({}, config_1.defaultKotlinGeneratorConfig), { packageName: 'com.openapi.generated', packageSuffix: '.api' });