@goast/kotlin 0.4.18-springwebclient1 → 0.4.19

package/src/src/generators/services/okhttp3-clients/okhttp3-clients-generator.ts

@@ -0,0 +1,130 @@
+import { resolve } from 'node:path';
+
+
+import fs from 'fs-extra';
+
+import {
+  type ApiService,
+  Factory,
+  type MaybePromise,
+  type OpenApiGeneratorContext,
+  OpenApiServicesGenerationProviderBase,
+  toCasing,
+} from '@goast/core';
+
+import { getAssetFileContent } from '../../../assets.js';
+import type { KotlinServicesGeneratorInput } from '../spring-controllers/index.js';
+import {
+  defaultKotlinOkHttp3ClientsGeneratorConfig,
+  type KotlinOkHttp3ClientGeneratorOutput,
+  type KotlinOkHttp3ClientsGeneratorConfig,
+  type KotlinOkHttp3ClientsGeneratorContext,
+  type KotlinOkHttp3ClientsGeneratorInput,
+  type KotlinOkHttp3ClientsGeneratorOutput,
+} from './models.js';
+import { DefaultKotlinOkHttp3Generator, type KotlinOkHttp3Generator } from './okhttp3-client-generator.js';
+import { getReferenceFactories } from './refs.js';
+
+type Input = KotlinOkHttp3ClientsGeneratorInput;
+type Output = KotlinOkHttp3ClientsGeneratorOutput;
+type Config = KotlinOkHttp3ClientsGeneratorConfig;
+type ServiceOutput = KotlinOkHttp3ClientGeneratorOutput;
+type Context = KotlinOkHttp3ClientsGeneratorContext;
+
+export class KotlinOkHttp3ClientsGenerator extends OpenApiServicesGenerationProviderBase<
+  Input,
+  Output,
+  Config,
+  ServiceOutput,
+  Context
+> {
+  private readonly _serviceGeneratorFactory: Factory<KotlinOkHttp3Generator, []>;
+
+  constructor(serviceGeneratorFactory?: Factory<KotlinOkHttp3Generator, []>) {
+    super();
+    this._serviceGeneratorFactory = serviceGeneratorFactory ?? Factory.fromValue(new DefaultKotlinOkHttp3Generator());
+  }
+
+  protected override async generateAdditionalFiles(ctx: KotlinOkHttp3ClientsGeneratorContext): 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, defaultKotlinOkHttp3ClientsGeneratorConfig);
+    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, '/'));
+    await fs.ensureDir(targetDir);
+
+    const files = [
+      'ApiAbstractions.kt',
+      'ApiClient.kt',
+      'ApiResponse.kt',
+      'Errors.kt',
+      'PartConfig.kt',
+      'RequestConfig.kt',
+      'RequestMethod.kt',
+      'ResponseExtensions.kt',
+      'Serializer.kt',
+    ];
+
+    for (const file of files) {
+      const sourcePath = `client/okhttp3/${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)
+        .replace(/@JSON_INCLUDE@/g, toCasing(ctx.config.serializerJsonInclude, 'snake'));
+      fs.writeFileSync(targetPath, fileContent);
+    }
+  }
+}

package/src/src/generators/services/okhttp3-clients/refs.ts

@@ -0,0 +1,55 @@
+import { kt } from '../../../ast/index.js';
+
+// See packages/kotlin/assets/client/okhttp3 for reference
+export function getReferenceFactories(infrastructurePackageName: string): {
+  multiValueMap: kt.ReferenceFactory;
+  collectionDelimiter: kt.ReferenceFactory;
+  defaultMultiValueConverter: kt.ReferenceFactory;
+  toMultiValueMap: kt.GenericReferenceFactory<1>;
+  apiClient: kt.ReferenceFactory;
+  responseType: kt.ReferenceFactory;
+  apiResponse: kt.GenericReferenceFactory<1>;
+  success: kt.GenericReferenceFactory<1>;
+  informational: kt.GenericReferenceFactory<1>;
+  redirection: kt.GenericReferenceFactory<1>;
+  clientError: kt.GenericReferenceFactory<1>;
+  serverError: kt.GenericReferenceFactory<1>;
+  clientException: kt.ReferenceFactory;
+  serverException: kt.ReferenceFactory;
+  partConfig: kt.GenericReferenceFactory<1>;
+  requestConfig: kt.GenericReferenceFactory<1>;
+  requestMethod: kt.ReferenceFactory;
+} {
+  return {
+    // ApiAbstractions.kt
+    multiValueMap: kt.reference.factory('MultiValueMap', infrastructurePackageName),
+    collectionDelimiter: kt.reference.factory('collectionDelimiter', infrastructurePackageName),
+    defaultMultiValueConverter: kt.reference.factory('defaultMultiValueConverter', infrastructurePackageName),
+    toMultiValueMap: kt.reference.genericFactory<1>('toMultiValueMap', infrastructurePackageName),
+
+    // ApiClient.kt
+    apiClient: kt.reference.factory('ApiClient', infrastructurePackageName),
+
+    // ApiResponse.kt
+    responseType: kt.reference.factory('ResponseType', infrastructurePackageName),
+    apiResponse: kt.reference.genericFactory<1>('ApiResponse', infrastructurePackageName),
+    success: kt.reference.genericFactory<1>('Success', infrastructurePackageName),
+    informational: kt.reference.genericFactory<1>('Informational', infrastructurePackageName),
+    redirection: kt.reference.genericFactory<1>('Redirection', infrastructurePackageName),
+    clientError: kt.reference.genericFactory<1>('ClientError', infrastructurePackageName),
+    serverError: kt.reference.genericFactory<1>('ServerError', infrastructurePackageName),
+
+    // Errors.kt
+    clientException: kt.reference.factory('ClientException', infrastructurePackageName),
+    serverException: kt.reference.factory('ServerException', infrastructurePackageName),
+
+    // PartConfig.kt
+    partConfig: kt.reference.genericFactory<1>('PartConfig', infrastructurePackageName),
+
+    // RequestConfig.kt
+    requestConfig: kt.reference.genericFactory<1>('RequestConfig', infrastructurePackageName),
+
+    // RequestMethod.kt
+    requestMethod: kt.reference.factory('RequestMethod', infrastructurePackageName),
+  };
+}

package/src/src/generators/services/spring-controllers/args.ts

@@ -0,0 +1,93 @@
+import type { ApiEndpoint, ApiResponse, ApiSchema, SourceBuilder } from '@goast/core';
+
+import type { kt } from '../../../ast/index.js';
+import type { ApiParameterWithMultipartInfo } from '../../../types.js';
+
+// #region API Response Entities
+export type GenerateApiResponseEntitiesFile = {
+  dirPath: string;
+  packageName: string;
+};
+
+export type GetApiResponseEntitiesFileContent = { packageName: string };
+
+export type GetApiResponseEntities = object;
+// #endregion
+
+// #region API Interface
+export type GenerateApiInterfaceFile = {
+  dirPath: string;
+  packageName: string;
+};
+
+export type GetApiInterfaceFileContent = { interfaceName: string };
+
+export type GetApiInterface = { interfaceName: string };
+
+export type GetApiInterfaceEndpointMethod = { endpoint: ApiEndpoint };
+
+export type GetApiResponseEntityClass = { endpoint: ApiEndpoint };
+// #endregion
+
+// #region API Controller
+export type GenerateApiControllerFile = {
+  dirPath: string;
+  packageName: string;
+};
+
+export type GetApiControllerFileContent = { controllerName: string };
+
+export type GetApiController = { controllerName: string };
+// #endregion
+
+// #region API Delegate Interface
+export type GenerateApiDelegateInterfaceFile = {
+  dirPath: string;
+  packageName: string;
+};
+
+export type GetApiDelegateInterfaceFileContent = { delegateInterfaceName: string };
+
+export type GetApiDelegateInterface = { delegateInterfaceName: string };
+
+export type GetApiDelegateInterfaceEndpointMethod = { endpoint: ApiEndpoint };
+// #endregion
+
+export type GetParameterType = {
+  endpoint: ApiEndpoint;
+  parameter: ApiParameterWithMultipartInfo;
+  type?: kt.Reference<SourceBuilder>;
+};
+
+export type GetResponseType = { endpoint: ApiEndpoint; response?: ApiResponse };
+
+export type GetTypeUsage<TBuilder extends SourceBuilder> = {
+  schema: ApiSchema | undefined;
+  nullable?: boolean;
+  fallback?: kt.Type<TBuilder>;
+  type?: kt.Reference<TBuilder>;
+};
+
+export type GetSchemaType = { schema: ApiSchema | undefined };
+
+export type GetControllerRequestMapping = { prefix?: string };
+
+export type GetBasePath = object;
+
+export type GetEndpointPath = { endpoint: ApiEndpoint };
+
+export type GetDirectoryPath = { packageName: string };
+
+export type GetPathConstantName = { endpoint: ApiEndpoint };
+
+export type GetPackageName = object;
+
+export type GetApiResponseEntityName = { endpoint: ApiEndpoint };
+
+export type GetApiInterfaceName = object;
+
+export type GetApiDelegateInterfaceName = object;
+
+export type GetApiControllerName = object;
+
+export type GetAllParameters = { endpoint: ApiEndpoint };

package/src/src/generators/services/spring-controllers/index.ts

@@ -0,0 +1,4 @@
+export * as DefaultKotlinSpringControllerGeneratorArgs from './args.js';
+export * from './models.js';
+export * from './spring-controller-generator.js';
+export * from './spring-controllers-generator.js';

package/src/src/generators/services/spring-controllers/models.ts

@@ -0,0 +1,71 @@
+import type {
+  ApiEndpoint,
+  ApiService,
+  DefaultGenerationProviderConfig,
+  OpenApiServicesGenerationProviderContext,
+} from '@goast/core';
+
+import type { KotlinImport } from '../../../common-results.js';
+import { defaultKotlinGeneratorConfig, type KotlinGeneratorConfig } from '../../../config.js';
+import type { KotlinModelsGeneratorOutput } from '../../models/index.js';
+import type { getReferenceFactories } from './refs.js';
+
+export type KotlinServicesGeneratorConfig = KotlinGeneratorConfig & {
+  packageName: string;
+  packageSuffix: string | ((service: ApiService | null) => string);
+
+  basePath?: string | RegExp | ((basePath: string, service: ApiService) => string);
+  pathModifier?: RegExp | ((path: string, endpoint: ApiEndpoint) => string);
+
+  addSwaggerAnnotations: boolean;
+  addJakartaValidationAnnotations: boolean;
+  arrayType: 'list' | 'flux';
+
+  strictResponseEntities: boolean;
+  defaultStatusCodes: number[];
+};
+
+export const defaultKotlinServicesGeneratorConfig: DefaultGenerationProviderConfig<KotlinServicesGeneratorConfig> = {
+  ...defaultKotlinGeneratorConfig,
+
+  packageName: 'com.openapi.generated',
+  packageSuffix: '.api',
+
+  addSwaggerAnnotations: true,
+  addJakartaValidationAnnotations: true,
+  arrayType: 'flux',
+
+  strictResponseEntities: false,
+  defaultStatusCodes: [400, 401, 403, 500, 501],
+};
+
+export type KotlinServicesGeneratorInput = KotlinModelsGeneratorOutput;
+
+export type KotlinServicesGeneratorOutput = {
+  kotlin: {
+    services: {
+      [serviceId: string]: KotlinServiceGeneratorOutput;
+    };
+  };
+};
+
+export type KotlinServiceGeneratorOutput = {
+  apiInterface: KotlinImport;
+  apiController: KotlinImport;
+  apiDelegate: KotlinImport;
+};
+
+export type KotlinServicesGeneratorContext =
+  & OpenApiServicesGenerationProviderContext<
+    KotlinServicesGeneratorInput,
+    KotlinServicesGeneratorOutput,
+    KotlinServicesGeneratorConfig,
+    KotlinServiceGeneratorOutput
+  >
+  & {
+    refs: ReturnType<typeof getReferenceFactories>;
+  };
+
+export type KotlinServiceGeneratorContext = KotlinServicesGeneratorContext & {
+  service: ApiService;
+};

package/src/src/generators/services/spring-controllers/refs.ts

@@ -0,0 +1,17 @@
+import { toCasing } from '@goast/core';
+import { kt } from '../../../ast/index.js';
+import type { KotlinServicesGeneratorConfig } from './models.js';
+
+export function getReferenceFactories(options: KotlinServicesGeneratorConfig): {
+  apiExceptionHandler: kt.ReferenceFactory;
+} {
+  const packageSuffix = typeof options.packageSuffix === 'string' ? options.packageSuffix : options.packageSuffix(null);
+  const packageName = options.packageName + packageSuffix;
+
+  return {
+    apiExceptionHandler: kt.reference.factory(
+      toCasing('ApiExceptionHandler', options.typeNameCasing),
+      packageName,
+    ),
+  };
+}