@goast/kotlin 0.4.2-beta1 → 0.4.3

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

@@ -0,0 +1,557 @@
+import { dirname } from 'node:path';
+
+
+import fs from 'fs-extra';
+
+import {
+  type ApiParameter,
+  type ApiSchema,
+  type AppendValueGroup,
+  appendValueGroup,
+  builderTemplate as s,
+  createOverwriteProxy,
+  type MaybePromise,
+  resolveAnyOfAndAllOf,
+  SourceBuilder,
+  toCasing,
+} from '@goast/core';
+
+import { kt } from '../../../ast/index.js';
+import type { KtValue } from '../../../ast/nodes/types.js';
+import type { KotlinImport } from '../../../common-results.js';
+import { KotlinFileBuilder } from '../../../file-builder.js';
+import type { ApiParameterWithMultipartInfo } from '../../../types.js';
+import { modifyString } from '../../../utils.js';
+import { KotlinFileGenerator } from '../../file-generator.js';
+import type { DefaultKotlinOkHttp3GeneratorArgs as Args } from './index.js';
+import type { KotlinOkHttp3ClientGeneratorContext, KotlinOkHttp3ClientGeneratorOutput } from './models.js';
+
+type Context = KotlinOkHttp3ClientGeneratorContext;
+type Output = KotlinOkHttp3ClientGeneratorOutput;
+type Builder = KotlinFileBuilder;
+
+export interface KotlinOkHttp3Generator<TOutput extends Output = Output> {
+  generate(ctx: Context): MaybePromise<TOutput>;
+}
+
+export class DefaultKotlinOkHttp3Generator extends KotlinFileGenerator<Context, Output>
+  implements KotlinOkHttp3Generator {
+  public generate(ctx: KotlinOkHttp3ClientGeneratorContext): MaybePromise<KotlinImport> {
+    const typeName = this.getApiClientName(ctx, {});
+    const packageName = this.getPackageName(ctx, {});
+    const filePath = this.getFilePath(ctx, { packageName });
+    fs.ensureDirSync(dirname(filePath));
+
+    console.log(`Generating client for service ${ctx.service.name} to ${filePath}...`);
+
+    const builder = new KotlinFileBuilder(packageName, ctx.config);
+    builder.append(this.getClientFileContent(ctx, {}));
+
+    fs.writeFileSync(filePath, builder.toString());
+
+    return { typeName, packageName };
+  }
+
+  protected getClientFileContent(ctx: Context, _args: Args.GetClientFileContent): AppendValueGroup<Builder> {
+    return appendValueGroup([this.getClientClass(ctx, {})]);
+  }
+
+  protected getClientClass(ctx: Context, _args: Args.GetClientClass): kt.Class<Builder> {
+    return kt.class(this.getApiClientName(ctx, {}), {
+      annotations: [
+        ctx.service.endpoints.length === 0 || ctx.service.endpoints.some((x) => !x.deprecated)
+          ? null
+          : kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]),
+      ],
+      extends: ctx.refs.apiClient(),
+      primaryConstructor: kt.constructor(
+        [
+          kt.parameter('basePath', kt.refs.string(), { default: 'defaultBasePath' }),
+          kt.parameter('client', kt.refs.okhttp3.okHttpClient(), {
+            default: 'defaultClient'
+          }),
+        ],
+        null,
+        {
+          delegateTarget: 'super',
+          delegateArguments: ['basePath', 'client'],
+        },
+      ),
+      companionObject: this.getClientCompanionObject(ctx, {}),
+      members: [
+        ...ctx.service.endpoints.flatMap((endpoint) =>
+          this.getEndpointClientMembers(ctx, { endpoint, parameters: this.getAllParameters(ctx, { endpoint }) })
+        ),
+        ...this.getAdditionalClientMembers(ctx, {}),
+      ],
+    });
+  }
+
+  protected getClientCompanionObject(ctx: Context, _args: Args.GetClientCompanionObject): kt.Object<Builder> {
+    const result = kt.object<Builder>();
+
+    result.members.push(
+      kt.property('defaultBasePath', {
+        annotations: [kt.annotation(kt.refs.jvmStatic())],
+        type: kt.refs.string(),
+        delegate: kt.refs.lazyFun.infer(),
+        delegateArguments: [
+          kt.lambda(
+            [],
+            kt.call(
+              [kt.call([kt.refs.java.system(), 'getProperties'], []), 'getProperty'],
+              [kt.call([ctx.refs.apiClient(), 'baseUrlKey']), kt.string(this.getBasePath(ctx, {}))],
+            ),
+          ),
+        ],
+      }),
+    );
+
+    return result;
+  }
+
+  protected getEndpointClientMembers(ctx: Context, args: Args.GetEndpointClientMembers): kt.ClassMember<Builder>[] {
+    const { endpoint, parameters } = args;
+    const responseSchema = this.getResponseSchema(ctx, { endpoint });
+    return [
+      this.getEndpointClientMethod(ctx, { endpoint, parameters, responseSchema }),
+      this.getEndpointClientHttpInfoMethod(ctx, { endpoint, parameters, responseSchema }),
+      this.getEndpointClientRequestConfigMethod(ctx, { endpoint, parameters }),
+    ];
+  }
+
+  protected getEndpointClientMethod(ctx: Context, args: Args.GetEndpointClientMethod): kt.Function<Builder> {
+    const { endpoint, parameters, responseSchema } = args;
+
+    return kt.function(toCasing(endpoint.name, ctx.config.functionNameCasing), {
+      doc: kt.doc(endpoint.summary, [
+        kt.docTag('throws', 'IllegalStateException', 'If the request is not correctly configured'),
+        kt.docTag('throws', 'IOException', 'Rethrows the OkHttp execute method exception'),
+        kt.docTag(
+          'throws',
+          'UnsupportedOperationException',
+          'If the API returns an informational or redirection response',
+        ),
+        kt.docTag('throws', 'ClientException', 'If the API returns a client error response'),
+        kt.docTag('throws', 'ServerException', 'If the API returns a server error response'),
+      ]),
+      annotations: [
+        kt.annotation(kt.refs.throws(), [
+          kt.refs.java.illegalStateException({ classReference: true }),
+          kt.refs.java.ioException({ classReference: true }),
+          kt.refs.java.unsupportedOperationException({ classReference: true }),
+          ctx.refs.clientException({ classReference: true }),
+          ctx.refs.serverException({ classReference: true }),
+        ]),
+        endpoint.deprecated ? kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]) : null,
+      ],
+      parameters: parameters.map((p) =>
+        kt.parameter(
+          toCasing(p.name, ctx.config.parameterNameCasing),
+          this.getParameterType(ctx, { endpoint, parameter: p }),
+          {
+            description: p.description,
+            default: !p.required ? kt.toNode(p.schema?.default) : null,
+          },
+        )
+      ),
+      returnType: this.getTypeUsage(ctx, { schema: responseSchema, fallback: kt.refs.unit() }),
+      body: this.getEndpointClientMethodBody(ctx, { endpoint, parameters, responseSchema }),
+    });
+  }
+
+  protected getEndpointClientMethodBody(
+    ctx: Context,
+    args: Args.GetEndpointClientMethodBody,
+  ): AppendValueGroup<Builder> {
+    const { endpoint, parameters, responseSchema } = args;
+
+    return appendValueGroup(
+      [
+        s`val localVarResponse = ${
+          kt.call(
+            [toCasing(endpoint.name + '_WithHttpInfo', ctx.config.functionNameCasing)],
+            parameters.map((x) => x.name),
+          )
+        }`,
+        '',
+        s`return when (localVarResponse.responseType) {${s.indent`
+            ${ctx.refs.responseType()}.Success -> ${
+          responseSchema === undefined
+            ? kt.refs.unit()
+            : s`(localVarResponse as ${ctx.refs.success(['*'])}).data as ${
+              this.getTypeUsage(ctx, {
+                schema: responseSchema,
+              })
+            }`
+        }
+            ${ctx.refs.responseType()}.Informational -> throw ${kt.refs.java.unsupportedOperationException()}("Client does not support Informational responses.")
+            ${ctx.refs.responseType()}.Redirection -> throw ${kt.refs.java.unsupportedOperationException()}("Client does not support Redirection responses.")
+            ${ctx.refs.responseType()}.ClientError -> {${s.indent`
+              val localVarError = localVarResponse as ${ctx.refs.clientError(['*'])}
+              throw ${ctx.refs.clientException()}(${s.indent`
+                "Client error : \${localVarError.statusCode} \${localVarError.message.orEmpty()}",
+                localVarError.statusCode,
+                localVarResponse`}
+              )`}
+            }
+
+            ${ctx.refs.responseType()}.ServerError -> {${s.indent`
+              val localVarError = localVarResponse as ${ctx.refs.serverError(['*'])}
+              throw ${ctx.refs.serverException()}(${s.indent`
+                "Server error : \${localVarError.statusCode} \${localVarError.message.orEmpty()}",
+                localVarError.statusCode,
+                localVarResponse`}
+              )`}
+            }`}
+          }`,
+      ],
+      '\n',
+    );
+  }
+
+  protected getEndpointClientHttpInfoMethod(
+    ctx: Context,
+    args: Args.GetEndpointClientHttpInfoMethod,
+  ): kt.Function<Builder> {
+    const { endpoint, parameters, responseSchema } = args;
+
+    return kt.function(toCasing(args.endpoint.name, ctx.config.functionNameCasing) + 'WithHttpInfo', {
+      doc: kt.doc(endpoint.summary, [
+        kt.docTag('throws', 'IllegalStateException', 'If the request is not correctly configured'),
+        kt.docTag('throws', 'IOException', 'Rethrows the OkHttp execute method exception'),
+      ]),
+      annotations: [
+        kt.annotation(kt.refs.throws(), [
+          kt.refs.java.illegalStateException({ classReference: true }),
+          kt.refs.java.ioException({ classReference: true }),
+        ]),
+        endpoint.deprecated ? kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]) : null,
+      ],
+      parameters: parameters.map((p) =>
+        kt.parameter(
+          toCasing(p.name, ctx.config.parameterNameCasing),
+          this.getParameterType(ctx, { endpoint, parameter: p }),
+          {
+            description: p.description,
+            default: !p.required ? kt.toNode(p.schema?.default) : null,
+          },
+        )
+      ),
+      returnType: ctx.refs.apiResponse([
+        this.getTypeUsage(ctx, { schema: responseSchema, fallback: kt.refs.unit({ nullable: true }), nullable: true }),
+      ]),
+      body: this.getEndpointClientHttpInfoMethodBody(ctx, { endpoint, parameters, responseSchema }),
+    });
+  }
+
+  protected getEndpointClientHttpInfoMethodBody(
+    ctx: Context,
+    args: Args.GetEndpointClientHttpInfoMethodBody,
+  ): AppendValueGroup<Builder> {
+    const { endpoint, parameters, responseSchema } = args;
+
+    return appendValueGroup(
+      [
+        s`val localVariableConfig = ${
+          kt.call(
+            [toCasing(endpoint.name, 'camel') + 'RequestConfig'],
+            parameters.map((x) => x.name),
+          )
+        }`,
+        s`return ${
+          kt.call(
+            [
+              kt.reference('request', null, {
+                generics: [
+                  this.getRequestBodyType(ctx, { endpoint }),
+                  this.getTypeUsage(ctx, { schema: responseSchema, fallback: kt.refs.unit() }),
+                ],
+              }),
+            ],
+            ['localVariableConfig'],
+          )
+        }`,
+      ],
+      '\n',
+    );
+  }
+
+  protected getEndpointClientRequestConfigMethod(
+    ctx: Context,
+    args: Args.GetEndpointClientRequestConfigMethod,
+  ): kt.Function<Builder> {
+    const { endpoint, parameters } = args;
+    const operationName = toCasing(endpoint.name, ctx.config.functionNameCasing);
+
+    return kt.function(toCasing(args.endpoint.name, ctx.config.functionNameCasing) + 'RequestConfig', {
+      accessModifier: 'private',
+      doc: kt.doc(`To obtain the request config of the operation ${operationName}`),
+      annotations: [endpoint.deprecated ? kt.annotation(kt.refs.deprecated(), [kt.argument(kt.string(''))]) : null],
+      parameters: parameters.map((p) =>
+        kt.parameter(
+          toCasing(p.name, ctx.config.parameterNameCasing),
+          this.getParameterType(ctx, { endpoint, parameter: p }),
+          {
+            description: p.description,
+            default: !p.required ? kt.toNode(p.schema?.default) : null,
+          },
+        )
+      ),
+      returnType: ctx.refs.requestConfig([this.getRequestBodyType(ctx, { endpoint })]),
+      body: this.getEndpointClientRequestConfigMethodBody(ctx, { endpoint, parameters }),
+    });
+  }
+
+  protected getEndpointClientRequestConfigMethodBody(
+    ctx: Context,
+    args: Args.GetEndpointClientRequestConfigMethodBody,
+  ): AppendValueGroup<Builder> {
+    const { endpoint, parameters } = args;
+    const queryParameters = parameters.filter((x) => x.target === 'query');
+    const result = appendValueGroup<Builder>([], '\n');
+
+    if (endpoint.requestBody) {
+      if (endpoint.requestBody.content[0]?.type === 'multipart/form-data') {
+        const partConfigs = parameters
+          .filter((x) => x.multipart)
+          .map<KtValue<Builder>>((param) => {
+            const paramName = toCasing(param.name, ctx.config.parameterNameCasing);
+            return s`"${param.multipart?.name ?? ''}" to ${ctx.refs.partConfig.infer()}(body = ${paramName})`;
+          });
+        result.values.push(
+          s`val localVariableBody = ${
+            kt.call(kt.refs.mapOf([kt.refs.string(), ctx.refs.partConfig(['*'])]), partConfigs)
+          }`,
+        );
+      } else {
+        const bodyParamName = toCasing(this.getRequestBodyParamName(ctx, { endpoint }), ctx.config.parameterNameCasing);
+        result.values.push(`val localVariableBody = ${bodyParamName}`);
+      }
+    }
+
+    result.values.push(
+      s`val localVariableQuery: ${ctx.refs.multiValueMap()} = ${
+        kt.call(
+          [kt.refs.mutableMapOf([kt.refs.string(), kt.refs.list([kt.refs.string()])])],
+          [],
+        )
+      }${
+        queryParameters.length === 0 ? '' : s.indent`
+            .apply {${s.indent`
+              ${
+          appendValueGroup(
+            queryParameters.map((param) => {
+              const paramName = toCasing(param.name, ctx.config.parameterNameCasing);
+              const toString = param.schema?.kind === 'array' ? '.joinToString()' : '.toString()';
+              const put = s<Builder>`put(${kt.string(paramName)}, listOf(${paramName}${toString}))`;
+              return param.required ? put : s<Builder>`if (${paramName} != null) {${s.indent`
+                        ${put}`}
+                      }`;
+            }),
+            '\n',
+          )
+        }`}
+            }`
+      }`,
+    );
+
+    result.values.push('val localVariableHeaders: MutableMap<String, String> = mutableMapOf()');
+    if (endpoint.requestBody?.content[0] !== undefined) {
+      result.values.push(`localVariableHeaders["Content-Type"] = "${endpoint.requestBody?.content[0].type}"`);
+    }
+
+    result.values.push(
+      s`return ${
+        kt.call(
+          [ctx.refs.requestConfig.infer()],
+          [
+            kt.argument.named('method', kt.call([ctx.refs.requestMethod(), endpoint.method.toUpperCase()])),
+            kt.argument.named('path', kt.string(this.getPathWithInterpolation(ctx, { endpoint }), { template: true })),
+            kt.argument.named('query', 'localVariableQuery'),
+            kt.argument.named('headers', 'localVariableHeaders'),
+            kt.argument.named('requiresAuthentication', 'false'),
+            endpoint.requestBody ? kt.argument.named('body', 'localVariableBody') : null,
+          ],
+        )
+      }`,
+    );
+
+    return result;
+  }
+
+  protected getAdditionalClientMembers(
+    _ctx: Context,
+    _args: Args.GetAdditionalClientMembers,
+  ): kt.ClassMember<Builder>[] {
+    return [
+      kt.function('encodeURIComponent', {
+        accessModifier: 'private',
+        parameters: [kt.parameter('uriComponent', kt.refs.string())],
+        returnType: kt.refs.string(),
+        singleExpression: true,
+        body:
+          s`${kt.refs.okhttp3.httpUrl()}.Builder().scheme("http").host("localhost").addPathSegment(uriComponent).build().encodedPathSegments[0]`,
+      }),
+    ];
+  }
+
+  protected getParameterType(ctx: Context, args: Args.GetParameterType): kt.Type<Builder> {
+    const { parameter } = args;
+    if (parameter.multipart?.isFile) {
+      return kt.refs.java.file();
+    }
+    return this.getTypeUsage(ctx, {
+      schema: parameter.schema,
+      nullable: !parameter.required,
+    });
+  }
+
+  protected getRequestBodyType(ctx: Context, args: Args.GetRequestBodyType): kt.Type<Builder> {
+    const { endpoint } = args;
+    const content = endpoint.requestBody?.content[0];
+    return content?.type === 'multipart/form-data'
+      ? kt.refs.map([kt.refs.string(), ctx.refs.partConfig(['*'])])
+      : this.getTypeUsage(ctx, { schema: content?.schema, fallback: kt.refs.unit() });
+  }
+
+  protected getTypeUsage(ctx: Context, args: Args.GetTypeUsage<Builder>): kt.Type<Builder> {
+    const { schema, nullable, fallback } = args;
+    const type = this.getSchemaType(ctx, { schema });
+    return type
+      ? createOverwriteProxy(type, { nullable: nullable ?? type.nullable })
+      : (fallback ?? kt.refs.any({ nullable }));
+  }
+
+  protected getPackageName(ctx: Context, _args: Args.GetPackageName): string {
+    const packageSuffix = typeof ctx.config.packageSuffix === 'string'
+      ? ctx.config.packageSuffix
+      : ctx.config.packageSuffix(ctx.service);
+    return ctx.config.packageName + packageSuffix;
+  }
+
+  protected getPathWithInterpolation(ctx: Context, args: Args.GetPathWithInterpolation): string {
+    const { endpoint } = args;
+    let path = this.getEndpointPath(ctx, { endpoint });
+    endpoint.parameters
+      .filter((x) => x.target === 'path')
+      .forEach((parameter) => {
+        path = path.replace(
+          `{${parameter.name}}`,
+          `\${encodeURIComponent(${toCasing(parameter.name, 'camel')}.toString())}`,
+        );
+      });
+    return path;
+  }
+
+  protected getResponseSchema(_ctx: Context, args: Args.GetResponseSchema): ApiSchema | undefined {
+    const { endpoint } = args;
+    return endpoint.responses.find((x) => !x.statusCode || (x.statusCode >= 200 && x.statusCode < 300))
+      ?.contentOptions[0]?.schema;
+  }
+
+  protected getSchemaType(ctx: Context, args: Args.GetSchemaType): kt.Reference<SourceBuilder> | undefined {
+    const { schema } = args;
+    return schema && ctx.input.kotlin.models[schema.id].type;
+  }
+
+  protected getAllParameters(ctx: Context, args: Args.GetAllParameters): ApiParameterWithMultipartInfo[] {
+    const { endpoint } = args;
+    const parameters = endpoint.parameters.filter(
+      (parameter) => parameter.target === 'query' || parameter.target === 'path',
+    );
+    if (endpoint.requestBody) {
+      const content = endpoint.requestBody.content[0];
+      let schema = content.schema;
+
+      if (content.type === 'multipart/form-data') {
+        if (schema && schema.kind === 'object') {
+          schema = resolveAnyOfAndAllOf(schema, true) ?? schema;
+          const properties = schema.properties ?? {};
+          for (const [name, property] of properties.entries()) {
+            parameters.push(
+              Object.assign(
+                this.createApiParameter({
+                  id: `multipart-${name}`,
+                  name,
+                  target: 'body',
+                  schema: property.schema,
+                  required: schema.required.has(name),
+                  description: property.schema.description,
+                }),
+                {
+                  multipart: {
+                    name,
+                    isFile: property.schema.kind === 'string' && property.schema.format === 'binary',
+                  },
+                },
+              ),
+            );
+          }
+        }
+      } else {
+        parameters.push(
+          this.createApiParameter({
+            id: 'body',
+            name: this.getRequestBodyParamName(ctx, { endpoint }),
+            target: 'body',
+            schema,
+            required: endpoint.requestBody.required,
+            description: endpoint.requestBody.description,
+          }),
+        );
+      }
+    }
+
+    return parameters.sort((a, b) => (a.required === b.required ? 0 : a.required ? -1 : 1));
+  }
+
+  protected getRequestBodyParamName(ctx: Context, args: Args.GetRequestBodyParamName): string {
+    const { endpoint } = args;
+    const schema = endpoint.requestBody?.content[0].schema;
+    const schemaInfo = this.getSchemaType(ctx, { schema });
+    return toCasing(
+      schemaInfo && schemaInfo.name !== 'Any' ? SourceBuilder.build((b) => kt.reference.write(b, schemaInfo)) : 'body',
+      ctx.config.parameterNameCasing,
+    );
+  }
+
+  protected getBasePath(ctx: Context, _args: Args.GetBasePath): string {
+    return modifyString(
+      (ctx.service.$src ?? ctx.service.endpoints[0]?.$src)?.document.servers?.[0]?.url ?? '/',
+      ctx.config.basePath,
+      ctx.service,
+    );
+  }
+
+  protected getEndpointPath(ctx: Context, args: Args.GetEndpointPath): string {
+    const { endpoint } = args;
+    return modifyString(endpoint.path, ctx.config.pathModifier, endpoint);
+  }
+
+  protected getFilePath(ctx: Context, args: Args.GetFilePath): string {
+    const { packageName } = args;
+    return `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}/${this.getApiClientName(ctx, {})}.kt`;
+  }
+
+  protected getApiClientName(ctx: Context, _args: Args.GetApiClientName): string {
+    return toCasing(ctx.service.name, ctx.config.typeNameCasing) + 'ApiClient';
+  }
+
+  private createApiParameter(data: Partial<ApiParameter> & Pick<ApiParameter, 'id' | 'name' | 'target'>): ApiParameter {
+    return {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      $src: undefined!,
+      $ref: undefined,
+      schema: undefined,
+      required: false,
+      description: undefined,
+      allowEmptyValue: undefined,
+      allowReserved: undefined,
+      deprecated: false,
+      explode: undefined,
+      style: undefined,
+      ...data,
+    };
+  }
+}

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

@@ -0,0 +1,128 @@
+import { resolve } from 'node:path';
+
+
+import fs from 'fs-extra';
+
+import {
+  type ApiService,
+  Factory,
+  type MaybePromise,
+  type OpenApiGeneratorContext,
+  OpenApiServicesGenerationProviderBase,
+} 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);
+      fs.writeFileSync(targetPath, fileContent);
+    }
+  }
+}