@goast/kotlin 0.5.7 → 0.5.9-beta.1

package/src/src/generators/services/spring-reactive-web-clients/spring-reactive-web-clients-generator.ts

@@ -1,125 +0,0 @@
-import { resolve } from 'node:path';
-
-import {
-  type ApiService,
-  Factory,
-  type MaybePromise,
-  type OpenApiGeneratorContext,
-  OpenApiServicesGenerationProviderBase,
-  writeGeneratedFile,
-} from '@goast/core';
-
-import { getAssetFileContent } from '../../../assets.js';
-import type { KotlinServicesGeneratorInput } from '../spring-controllers/index.js';
-import {
-  defaultKotlinSpringReactiveWebClientsGeneratorConfig,
-  type KotlinSpringReactiveWebClientGeneratorOutput,
-  type KotlinSpringReactiveWebClientsGeneratorConfig,
-  type KotlinSpringReactiveWebClientsGeneratorContext,
-  type KotlinSpringReactiveWebClientsGeneratorInput,
-  type KotlinSpringReactiveWebClientsGeneratorOutput,
-} from './models.js';
-import { getReferenceFactories } from './refs.js';
-import {
-  DefaultKotlinSpringReactiveWebClientGenerator,
-  type KotlinSpringReactiveWebClientGenerator,
-} from './spring-reactive-web-client-generator.js';
-
-type Input = KotlinSpringReactiveWebClientsGeneratorInput;
-type Output = KotlinSpringReactiveWebClientsGeneratorOutput;
-type Config = KotlinSpringReactiveWebClientsGeneratorConfig;
-type ServiceOutput = KotlinSpringReactiveWebClientGeneratorOutput;
-type Context = KotlinSpringReactiveWebClientsGeneratorContext;
-
-export class KotlinSpringReactiveWebClientsGenerator extends OpenApiServicesGenerationProviderBase<
-  Input,
-  Output,
-  Config,
-  ServiceOutput,
-  Context
-> {
-  private readonly _serviceGeneratorFactory: Factory<KotlinSpringReactiveWebClientGenerator, []>;
-
-  constructor(serviceGeneratorFactory?: Factory<KotlinSpringReactiveWebClientGenerator, []>) {
-    super();
-    this._serviceGeneratorFactory = serviceGeneratorFactory ??
-      Factory.fromValue(new DefaultKotlinSpringReactiveWebClientGenerator());
-  }
-
-  protected override async generateAdditionalFiles(ctx: Context): Promise<void> {
-    await this.copyInfrastructureFiles(ctx);
-  }
-
-  protected initResult(): Output {
-    return {
-      kotlin: {
-        clients: {},
-      },
-    };
-  }
-
-  protected generateService(ctx: Context, service: ApiService): MaybePromise<ServiceOutput> {
-    const serviceGenerator = this._serviceGeneratorFactory.create();
-    return serviceGenerator.generate({
-      ...ctx,
-      service,
-    });
-  }
-
-  protected addServiceResult(ctx: Context, service: ApiService, result: ServiceOutput): void {
-    ctx.output.kotlin.clients[service.id] = result;
-  }
-
-  protected buildContext(
-    context: OpenApiGeneratorContext<KotlinServicesGeneratorInput>,
-    config?: Partial<Config> | undefined,
-  ): Context {
-    context.data.services = context.data.services.filter((x) => x.name !== 'exclude-from-generation');
-    const providerContext = this.getProviderContext(
-      context,
-      config,
-      defaultKotlinSpringReactiveWebClientsGeneratorConfig,
-    );
-    const infrastructurePackageName = this.getInfrastructurePackageName(providerContext.config);
-    return Object.assign(providerContext, {
-      infrastructurePackageName,
-      refs: getReferenceFactories(infrastructurePackageName),
-    });
-  }
-
-  protected getInfrastructurePackageName(config: Config): string {
-    if (typeof config.infrastructurePackageName === 'string') {
-      return config.infrastructurePackageName;
-    }
-    if (config.infrastructurePackageName.mode === 'append-package-name') {
-      return config.packageName + config.infrastructurePackageName.value;
-    }
-    if (config.infrastructurePackageName.mode === 'append-full-package-name') {
-      return this.getPackageName(config) + config.infrastructurePackageName.value;
-    }
-
-    return config.infrastructurePackageName.value;
-  }
-
-  protected getPackageName(config: Config): string {
-    const packageSuffix = typeof config.packageSuffix === 'string' ? config.packageSuffix : config.packageSuffix();
-    return config.packageName + packageSuffix;
-  }
-
-  private async copyInfrastructureFiles(ctx: Context): Promise<void> {
-    const targetDir = resolve(ctx.config.outputDir, ctx.infrastructurePackageName.replace(/\./g, '/'));
-
-    const files = [
-      'ApiRequestFile.kt',
-    ];
-
-    for (const file of files) {
-      const sourcePath = `client/spring-reactive-web-clients/${file}`;
-      const targetPath = resolve(targetDir, file);
-      console.log(`Copying asset file "${sourcePath}" to "${targetPath}"`);
-      const fileContent = (await getAssetFileContent(sourcePath))
-        .replace(/@PACKAGE_NAME@/g, ctx.infrastructurePackageName);
-      writeGeneratedFile(ctx.config, targetPath, fileContent);
-    }
-  }
-}

package/src/src/import-collection.ts

@@ -1,98 +0,0 @@
-import { type SourceBuilderOptions, StringBuilder } from '@goast/core';
-
-import type { KotlinImport } from './common-results.js';
-import { defaultKotlinGeneratorConfig } from './config.js';
-
-export type ImportCollectionOptions = {
-  globalImports: string[];
-};
-
-export const defaultImportCollectionOptions: ImportCollectionOptions = {
-  globalImports: defaultKotlinGeneratorConfig.globalImports,
-};
-
-export class ImportCollection {
-  private readonly _imports: Map<string, Set<string>> = new Map();
-  private readonly _options: ImportCollectionOptions;
-
-  constructor(options: Partial<ImportCollectionOptions> = {}) {
-    this._options = { ...defaultImportCollectionOptions, ...options };
-  }
-
-  public get hasImports(): boolean {
-    return this._imports.size > 0;
-  }
-
-  public get imports(): KotlinImport[] {
-    return Array.from(this._imports.entries())
-      .map(([fromPackage, importNames]) =>
-        Array.from(importNames).map((importName) => ({
-          packageName: fromPackage,
-          typeName: importName,
-        }))
-      )
-      .flat();
-  }
-
-  public addImport(importName: string, fromModule: string): void;
-  public addImport(importObj: KotlinImport): void;
-  public addImport(importOrImportName: KotlinImport | string, fromModule?: string): void {
-    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]));
-    }
-  }
-
-  public addImports(imports: KotlinImport[]): void {
-    for (const importObj of imports) {
-      this.addImport(importObj);
-    }
-  }
-
-  public clear(): void {
-    this._imports.clear();
-  }
-
-  public toString(options?: Partial<SourceBuilderOptions>): string {
-    const builder = new StringBuilder(options);
-    this.writeTo(builder);
-    return builder.toString();
-  }
-
-  public writeTo(builder: StringBuilder) {
-    if (this._imports.size > 0) {
-      const globalPackages = this._options.globalImports
-        .filter((g) => g.endsWith('.*'))
-        .map((g) => g.substring(0, g.length - 2));
-      const globalImports = this._options.globalImports.filter((g) => !g.endsWith('.*'));
-
-      Array.from(this._imports.entries())
-        .filter(([packageName]) => !globalPackages.includes(packageName))
-        .flatMap(([packageName, importNames]) => Array.from(importNames).map((importName) => [packageName, importName]))
-        .map(([packageName, importName]) => `${packageName}.${importName}`)
-        .filter((importPath) => !globalImports.includes(importPath))
-        .sort((a, b) => {
-          if (isCoreImport(a) && !isCoreImport(b)) {
-            return 1;
-          } else if (!isCoreImport(a) && isCoreImport(b)) {
-            return -1;
-          }
-          return a.localeCompare(b);
-        })
-        .forEach((importPath) => builder.appendLine(`import ${importPath}`));
-    }
-  }
-}
-
-function isCoreImport(importPath: string): boolean {
-  return importPath.startsWith('kotlin.') || importPath.startsWith('java.') || importPath.startsWith('javax.');
-}

package/src/src/types.ts

@@ -1,3 +0,0 @@
-import type { ApiParameter } from '@goast/core';
-
-export type ApiParameterWithMultipartInfo = ApiParameter & { multipart?: { name: string; isFile: boolean } };

package/src/src/utils.ts

@@ -1,47 +0,0 @@
-import type { ApiComponent, Nullable } from '@goast/core';
-import path from 'node:path';
-import process from 'node:process';
-
-export function toKotlinStringLiteral(value: Nullable<string>): string {
-  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: string): string {
-  if (value.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*$/)) {
-    return value;
-  }
-  return `\`${value}\``;
-}
-
-export function modifyString<TArgs extends unknown[]>(
-  value: string,
-  modifier: string | RegExp | ((value: string, ...args: TArgs) => string) | undefined,
-  ...args: TArgs
-): string {
-  if (typeof modifier === 'string') {
-    return modifier;
-  }
-  if (modifier instanceof RegExp) {
-    const match = value.match(modifier);
-    return match?.[0] ?? value;
-  }
-  if (typeof modifier === 'function') {
-    return modifier(value, ...args);
-  }
-  return value;
-}
-
-export function getSourceDocLine<T>(component: ApiComponent<T>): string {
-  const file = path.relative(process.cwd(), component.$src.file).replace(/\\/g, '/');
-  const { line, col } = component.$src.pos;
-  return `Source: ${file}:${line}:${col} (${component.$src.path})`;
-}