@goast/kotlin 0.6.0-beta.1 → 0.6.0

package/src/src/file-builder.ts

@@ -0,0 +1,112 @@
+import { type AppendParam, type AppendValue, isAppendValue, SourceBuilder, writeGeneratedFile } from '@goast/core';
+
+import { KtNode } from './ast/node.js';
+import { defaultKotlinGeneratorConfig, type KotlinGeneratorConfig } from './config.js';
+import { ImportCollection } from './import-collection.js';
+
+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 type KotlinAppends<TAdditionalAppends> = KtNode<KotlinFileBuilder> | TAdditionalAppends;
+export type KotlinAppendParam<TBuilder extends KotlinFileBuilder, TAdditionalAppends> = AppendParam<
+  TBuilder,
+  KotlinAppends<TAdditionalAppends>
+>;
+
+export function isKotlinAppendValue<TBuilder extends KotlinFileBuilder>(
+  value: unknown,
+): value is AppendValue<TBuilder> {
+  return isAppendValue(value) || value instanceof KtNode;
+}
+
+export class KotlinFileBuilder<TAdditionalAppends = never> extends SourceBuilder<KotlinAppends<TAdditionalAppends>> {
+  public readonly packageName: string | undefined;
+  public readonly imports: ImportCollection = new ImportCollection();
+
+  public override get options(): KotlinGeneratorConfig {
+    return super.options as KotlinGeneratorConfig;
+  }
+
+  constructor(packageName?: string, options?: KotlinGeneratorConfig) {
+    super(options ?? defaultKotlinGeneratorConfig);
+    this.packageName = packageName;
+  }
+
+  public addImport(name: string, packageName?: string): this {
+    if (packageName !== undefined && packageName !== this.packageName) {
+      this.imports.addImport(name, packageName);
+    }
+    return this;
+  }
+
+  public appendAnnotation(name: string, packageName?: string, args?: AnnotationArgument<this>[]): this {
+    const allArgs: [key: string | undefined, value: AnnotationArgumentValue<this>][] = [];
+    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]) => c + (key ? key.length + 3 : 0) + (value?.length ?? 0), 0) > 80;
+      this.parenthesize('()', (builder) =>
+        builder
+          .appendLineIf(multiline)
+          .forEach(
+            allArgs,
+            (builder, [name, value]) =>
+              builder
+                .append(name ? `${name} = ` : '')
+                .append((builder) => (typeof value === 'string' ? builder.append(value) : value(builder))),
+            { separator: multiline ? ',\n' : ', ' },
+          )
+          .appendLineIf(multiline));
+    }
+
+    this.appendLine();
+
+    return this;
+  }
+
+  public override clear(): void {
+    super.clear();
+    this.imports.clear();
+  }
+
+  public override toString(addPadding: boolean = true): string {
+    return new SourceBuilder(this.options)
+      .if(this.packageName !== undefined, (builder) => builder.appendLine(`package ${this.packageName}`).appendLine())
+      .append((builder) => this.imports.writeTo(builder))
+      .if(addPadding, (builder) => builder.ensurePreviousLineEmpty())
+      .append(super.toString())
+      .if(addPadding, (builder) => builder.ensureCurrentLineEmpty())
+      .toString();
+  }
+
+  public writeToFile(filePath: string) {
+    writeGeneratedFile(this.options, filePath, this.toString());
+  }
+
+  protected override appendSingle(value: KotlinAppendParam<this, TAdditionalAppends>): void {
+    super.appendSingle(value);
+    if (value instanceof KtNode) {
+      value.write(this);
+    }
+  }
+}

package/src/src/generators/file-generator.ts

@@ -0,0 +1,71 @@
+import {
+  type MaybePromise,
+  type Nullable,
+  type OpenApiGenerationProviderContext,
+  type OpenApiGeneratorInput,
+  toCasing,
+} from '@goast/core';
+
+import type { KotlinGeneratorConfig } from '../config.js';
+import { toKotlinPropertyName, toKotlinStringLiteral } from '../utils.js';
+
+export abstract class KotlinFileGenerator<
+  TContext extends OpenApiGenerationProviderContext<OpenApiGeneratorInput, KotlinGeneratorConfig>,
+  TOutput,
+> {
+  public abstract generate(context: TContext): MaybePromise<TOutput>;
+
+  protected toPropertyName(context: TContext, name: string): string {
+    return toKotlinPropertyName(toCasing(name, context.config.propertyNameCasing));
+  }
+
+  /**
+   * The Kotlin constant names for the values of an enum, index-aligned with `values`.
+   *
+   * `toCasing` cannot be relied on alone: `getWords` strips leading digits and every non-alphanumeric
+   * character, so a purely numeric value (`1`, `1.1`), the empty string, or a value written only in
+   * punctuation or non-ASCII letters all case to `''` — which renders as a nameless enum constant and an
+   * empty `when` branch, neither of which is valid Kotlin. Such a value gets an identifier derived from its
+   * raw text instead, always prefixed with `_`. That prefix cannot collide with anything `toCasing`
+   * produces, because `getWords` strips leading non-alphanumerics.
+   *
+   * Names are then de-duplicated in declaration order (`_2`, `_2_2`, `_2_3`, ...), so two distinct raw
+   * values — `2` and `'2'`, say — can never share one constant.
+   */
+  protected toEnumValueNames(context: TContext, values: Nullable<readonly unknown[]>): string[] {
+    const names: string[] = [];
+    const used = new Set<string>();
+
+    for (const value of values ?? []) {
+      const raw = String(value);
+      let base = toCasing(raw, context.config.enumValueNameCasing);
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(base) || /^_+$/.test(base)) {
+        const sanitized = raw.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+        base = sanitized.length > 0 ? `_${sanitized}` : raw.length === 0 ? '_EMPTY' : '_VALUE';
+      }
+
+      let name = base;
+      for (let i = 2; used.has(name); i++) name = `${base}_${i}`;
+      used.add(name);
+      names.push(name);
+    }
+
+    return names;
+  }
+
+  /**
+   * The Kotlin constant name `value` is given among the enum's `values`, so that a reference to an enum
+   * constant always agrees with the constant `toEnumValueNames` declared for it. Values are matched by
+   * their string form, because that is what the generated enum stores. Falls back to the name `value`
+   * would get on its own if it is not among `values`.
+   */
+  protected toEnumValueName(context: TContext, values: Nullable<readonly unknown[]>, value: unknown): string {
+    const all = values ?? [];
+    const index = all.findIndex((x) => String(x) === String(value));
+    return index < 0 ? this.toEnumValueNames(context, [value])[0] : this.toEnumValueNames(context, all)[index];
+  }
+
+  protected toStringLiteral(_context: TContext, text: Nullable<string>): string {
+    return toKotlinStringLiteral(text);
+  }
+}

package/src/src/generators/index.ts

@@ -0,0 +1,5 @@
+export * from './file-generator.js';
+export * from './models/index.js';
+export * from './services/okhttp3-clients/index.js';
+export * from './services/spring-controllers/index.js';
+export * from './services/spring-reactive-web-clients/index.js';

package/src/src/generators/models/args.ts

@@ -0,0 +1,142 @@
+import type { ApiSchema, ApiSchemaProperty } from '@goast/core';
+
+export type GetFileContent = object;
+
+export type GetSchemaDeclaration = {
+  schema: ApiSchema;
+};
+
+export type GetClass = {
+  schema: ApiSchema<'object'>;
+};
+
+export type GetInterface = {
+  schema: ApiSchema<'object'>;
+};
+
+export type GetEnum = {
+  schema: ApiSchema;
+};
+
+export type GetSchemaDocDescription = {
+  schema: ApiSchema;
+};
+
+export type GetType = {
+  schema: ApiSchema;
+  nullable?: boolean;
+};
+
+export type GetGeneratedType = {
+  schema: ApiSchema;
+  nullable?: boolean;
+};
+
+export type GetAdditionalPropertiesType = {
+  schema: ApiSchema<'object'>;
+};
+
+export type GetDefaultValue = {
+  schema: ApiSchema;
+};
+
+export type GetClassParameter = {
+  schema: ApiSchema<'object'>;
+  inheritedSchemas: ApiSchema[];
+  parameters: ApiSchemaProperty[];
+  property: ApiSchemaProperty;
+};
+
+export type GetInterfaceProperty = {
+  schema: ApiSchema<'object'>;
+  property: ApiSchemaProperty;
+};
+
+export type GetAdditionalPropertiesProperty = {
+  schema: ApiSchema<'object'>;
+};
+
+export type GetAdditionalPropertiesSetter = {
+  schema: ApiSchema<'object'>;
+};
+
+export type GetAdditionalPropertiesGetter = {
+  schema: ApiSchema<'object'>;
+};
+
+export type GetJacksonJsonTypeInfoAnnotation = {
+  schema: ApiSchema;
+};
+
+export type GetJacksonJsonSubTypesAnnotation = {
+  schema: ApiSchema;
+};
+
+export type GetJacksonJsonClassDescriptionAnnotation = {
+  schema: ApiSchema;
+};
+
+export type GetJacksonJsonPropertyAnnotation = {
+  schema: ApiSchema;
+  property: ApiSchemaProperty;
+};
+
+export type GetJacksonJsonPropertyDescriptionAnnotation = {
+  schema: ApiSchema;
+  property: ApiSchemaProperty;
+};
+
+export type GetJacksonJsonIncludeAnnotation = {
+  schema: ApiSchema;
+  property: ApiSchemaProperty;
+};
+
+export type GetJakartaValidationAnnotations = {
+  schema: ApiSchema;
+  property: ApiSchemaProperty;
+};
+
+export type GetSwaggerSchemaAnnotation = {
+  schema: ApiSchema;
+  property: ApiSchemaProperty;
+};
+
+export type GetPackageName = {
+  schema: ApiSchema;
+};
+
+export type ShouldGenerateTypeDeclaration = {
+  schema: ApiSchema;
+};
+
+export type GetDeclarationTypeName = {
+  schema: ApiSchema;
+};
+
+export type GetInheritedSchemas = {
+  schema: ApiSchema;
+};
+
+export type GetClassProperties = {
+  schema: ApiSchema<'object'>;
+};
+
+export type SortProperties = {
+  schema: ApiSchema;
+  properties: Iterable<ApiSchemaProperty>;
+};
+
+export type NormalizeSchema = {
+  schema: ApiSchema;
+};
+
+export type NormalizeDiscriminatedBases = {
+  schema: ApiSchema;
+};
+
+export type HasProperty = {
+  schema: ApiSchema;
+  propertyName: string;
+  /** The schemas already inspected, so a composition that cycles back on itself terminates. */
+  visited?: Set<ApiSchema>;
+};

package/src/src/generators/models/index.ts

@@ -0,0 +1,4 @@
+export * as DefaultKotlinModelGeneratorArgs from './args.js';
+export * from './model-generator.js';
+export * from './models-generator.js';
+export * from './models.js';