@goast/kotlin 0.5.1-beta.1 → 0.5.1

package/src/src/ast/utils/to-kt-node.ts

@@ -0,0 +1,31 @@
+import type { BasicAppendValue, SourceBuilder } from '@goast/core';
+
+import { type KtCall, ktCall } from '../nodes/call.js';
+import { type KtString, ktString } from '../nodes/string.js';
+import { listOf, mapOf } from '../references/index.js';
+
+export function toKtNode<TBuilder extends SourceBuilder>(object: Record<string | number, unknown>): KtCall<TBuilder>;
+export function toKtNode<TBuilder extends SourceBuilder>(list: unknown[]): KtCall<TBuilder>;
+export function toKtNode<TBuilder extends SourceBuilder>(string: string): KtString<TBuilder>;
+export function toKtNode<TBuilder extends SourceBuilder>(value: unknown): BasicAppendValue<TBuilder>;
+export function toKtNode<TBuilder extends SourceBuilder>(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return ktCall(
+      [listOf.infer()],
+      value.map((x) => toKtNode<TBuilder>(x)),
+    );
+  }
+  if (typeof value === 'object' && value !== null) {
+    return ktCall(
+      [mapOf.infer()],
+      Object.entries(value).map(([k, v]) => ktCall([toKtNode(k), 'to'], [toKtNode(v)])),
+    );
+  }
+  if (value === null || value === undefined) {
+    return 'null';
+  }
+  if (typeof value === 'boolean' || typeof value === 'number') {
+    return String(value);
+  }
+  return ktString(String(value));
+}

package/src/src/ast/utils/write-kt-annotations.ts

@@ -0,0 +1,15 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtAnnotations<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+  options?: { multiline: boolean },
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  builder.forEach(filteredNodes, (b, a) => {
+    writeKtNode(b, a);
+    b.append(options?.multiline ? '\n' : ' ');
+  });
+}

package/src/src/ast/utils/write-kt-arguments.ts

@@ -0,0 +1,45 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { KtLambda } from '../nodes/lambda.js';
+import { type KtAppendValue, writeKtNode, writeKtNodes } from './write-kt-node.js';
+
+export function writeKtArguments<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+
+  if (filteredNodes.length === 0) {
+    builder.append('()');
+    return;
+  }
+
+  const lastNode = filteredNodes[filteredNodes.length - 1];
+  let lambda: KtAppendValue<TBuilder> | null = null;
+  if (lastNode instanceof KtLambda) {
+    lambda = lastNode;
+    filteredNodes.pop();
+  } else if (
+    typeof lastNode === 'object' &&
+    (!('name' in lastNode) || !lastNode.name) &&
+    'value' in lastNode &&
+    lastNode.value instanceof KtLambda
+  ) {
+    lambda = lastNode.value;
+    filteredNodes.pop();
+  }
+
+  const multiline = filteredNodes.length > 3;
+
+  builder.parenthesizeIf(
+    filteredNodes.length > 0,
+    '()',
+    (b) => writeKtNodes(b, filteredNodes, { separator: multiline ? ',\n' : ', ' }),
+    { multiline },
+  );
+
+  if (lambda) {
+    builder.append(' ');
+    writeKtNode(builder, lambda);
+  }
+}

package/src/src/ast/utils/write-kt-enum-values.ts

@@ -0,0 +1,27 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtEnumValues<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  const spacing = filteredNodes.some(
+    (v) =>
+      typeof v === 'object' &&
+      (('annotations' in v && Array.isArray(v.annotations) && v.annotations.length > 0) ||
+        ('doc' in v && v.doc) ||
+        ('members' in v && Array.isArray(v.members) && v.members.some(notNullish))),
+  );
+  const multiline = spacing ||
+    filteredNodes.length > 4 ||
+    filteredNodes.some(
+      (v) => typeof v === 'object' && 'arguments' in v && Array.isArray(v.arguments) && v.arguments.length > 0,
+    );
+  builder.forEach(
+    filteredNodes,
+    (b, v, i) => b.if(spacing && i > 0, (b) => b.ensurePreviousLineEmpty()).append((b) => writeKtNode(b, v)),
+    { separator: multiline ? ',\n' : ', ' },
+  );
+}

package/src/src/ast/utils/write-kt-generic-parameters.ts

@@ -0,0 +1,12 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtGenericParameters<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  if (filteredNodes.length === 0) return;
+  builder.parenthesize('<>', (b) => b.forEach(filteredNodes, writeKtNode, { separator: ', ' }));
+}

package/src/src/ast/utils/write-kt-members.ts

@@ -0,0 +1,25 @@
+import { isAppendValue, isAppendValueGroup, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
+
+import { KtProperty } from '../nodes/property.js';
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtMembers<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  members: Nullable<KtAppendValue<TBuilder>>[],
+  options?: { alreadyHasMembers?: boolean },
+): void {
+  const filteredMembers = members.filter(notNullish);
+  builder.forEach(filteredMembers, (b, m, i) =>
+    b.if(
+      () =>
+        !(m instanceof KtProperty && !m.doc && m.annotations.length === 0) &&
+        !isAppendValue(m) &&
+        !isAppendValueGroup(m),
+      (b) =>
+        b
+          .if(i > 0 || !!options?.alreadyHasMembers, (b) => b.ensurePreviousLineEmpty())
+          .append((b) => writeKtNode(b, m))
+          .if(i < filteredMembers.length - 1, (b) => b.ensurePreviousLineEmpty()),
+      (b) => b.append((b) => writeKtNode(b, m)).ensureCurrentLineEmpty(),
+    ));
+}

package/src/src/ast/utils/write-kt-node.ts

@@ -0,0 +1,37 @@
+import {
+  type AppendValue,
+  notNullish,
+  type Nullable,
+  type Separator,
+  type SingleOrMultiple,
+  type SourceBuilder,
+  toArray,
+} from '@goast/core';
+
+import { KtNode } from '../node.js';
+
+export type KtAppendValue<TBuilder extends SourceBuilder> = AppendValue<TBuilder> | KtNode<TBuilder>;
+
+export function writeKtNode<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  node: Nullable<KtAppendValue<TBuilder>>,
+): void {
+  if (node instanceof KtNode) {
+    node.write(builder);
+  } else {
+    builder.append(node);
+  }
+}
+
+export function writeKtNodes<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+  options?: { separator?: Separator<TBuilder, KtAppendValue<TBuilder>> },
+): void {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  if (filteredNodes.length === 1) {
+    writeKtNode(builder, filteredNodes[0]);
+  } else if (filteredNodes.length > 1) {
+    builder.forEach(filteredNodes, writeKtNode, { separator: options?.separator });
+  }
+}

package/src/src/ast/utils/write-kt-parameters.ts

@@ -0,0 +1,25 @@
+import { notNullish, type Nullable, type SingleOrMultiple, type SourceBuilder, toArray } from '@goast/core';
+
+import { type KtAppendValue, writeKtNode } from './write-kt-node.js';
+
+export function writeKtParameters<TBuilder extends SourceBuilder>(
+  builder: TBuilder,
+  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
+) {
+  const filteredNodes = toArray(nodes).filter(notNullish);
+  const hasAnnotations = filteredNodes.some(
+    (p) => typeof p === 'object' && 'annotations' in p && Array.isArray(p.annotations) && p.annotations.length > 0,
+  );
+  const multiline = filteredNodes.length > 2 || hasAnnotations;
+  const spacing = multiline && hasAnnotations;
+  builder.parenthesize(
+    '()',
+    (b) =>
+      b.forEach(
+        filteredNodes,
+        (b, p, i) => b.if(i > 0 && spacing, (b) => b.ensurePreviousLineEmpty()).append((b) => writeKtNode(b, p)),
+        { separator: multiline ? ',\n' : ', ' },
+      ),
+    { multiline },
+  );
+}

package/src/src/common-results.ts

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

package/src/src/config.ts

@@ -0,0 +1,41 @@
+import type {
+  DefaultGenerationProviderConfig,
+  OpenApiGeneratorConfig,
+  StringCasing,
+  StringCasingWithOptions,
+} from '@goast/core';
+
+export type KotlinGeneratorConfig = OpenApiGeneratorConfig & {
+  typeNameCasing: StringCasing | StringCasingWithOptions;
+  parameterNameCasing: StringCasing | StringCasingWithOptions;
+  functionNameCasing: StringCasing | StringCasingWithOptions;
+  propertyNameCasing: StringCasing | StringCasingWithOptions;
+  enumValueNameCasing: StringCasing | StringCasingWithOptions;
+  constantNameCasing: StringCasing | StringCasingWithOptions;
+
+  globalImports: string[];
+};
+
+export const defaultKotlinGeneratorConfig: DefaultGenerationProviderConfig<KotlinGeneratorConfig> = {
+  indent: { type: 'spaces', count: 4 },
+
+  typeNameCasing: 'pascal',
+  parameterNameCasing: 'camel',
+  functionNameCasing: 'camel',
+  propertyNameCasing: 'camel',
+  enumValueNameCasing: 'snake',
+  constantNameCasing: 'snake',
+
+  globalImports: [
+    'kotlin.*',
+    'kotlin.annotation.*',
+    'kotlin.collections.*',
+    'kotlin.comparisons.*',
+    'kotlin.io.*',
+    'kotlin.ranges.*',
+    'kotlin.sequences.*',
+    'kotlin.text.*',
+    'java.lang.*',
+    'kotlin.jvm.*',
+  ],
+};

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,29 @@
+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));
+  }
+
+  protected toEnumValueName(context: TContext, name: string): string {
+    return toKotlinPropertyName(toCasing(name, context.config.enumValueNameCasing));
+  }
+
+  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,132 @@
+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 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 HasProperty = {
+  schema: ApiSchema;
+  propertyName: string;
+};

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';