@goast/kotlin 0.5.14 → 0.6.0-beta.1

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

@@ -1,641 +0,0 @@
-import {
-  type ApiParameter,
-  type ApiSchema,
-  type AppendValueGroup,
-  appendValueGroup,
-  type BasicAppendValue,
-  builderTemplate as s,
-  createOverwriteProxy,
-  getSourceDisplayName,
-  type MaybePromise,
-  notNullish,
-  resolveAnyOfAndAllOf,
-  SourceBuilder,
-  toCasing,
-} from '@goast/core';
-
-import { kt } from '../../../ast/index.js';
-import type { KtValue } from '../../../ast/nodes/types.js';
-import { KotlinFileBuilder } from '../../../file-builder.js';
-import type { ApiParameterWithMultipartInfo } from '../../../types.js';
-import { getArrayItemStringEnumSchema, getSourceDocLine, getStringEnumSchema, modifyString } from '../../../utils.js';
-import { KotlinFileGenerator } from '../../file-generator.js';
-import type { DefaultKotlinSpringReactiveWebClientGeneratorArgs as Args } from './index.js';
-import type {
-  KotlinSpringReactiveWebClientGeneratorContext,
-  KotlinSpringReactiveWebClientGeneratorOutput,
-} from './models.js';
-
-type Context = KotlinSpringReactiveWebClientGeneratorContext;
-type Output = KotlinSpringReactiveWebClientGeneratorOutput;
-type Builder = KotlinFileBuilder;
-
-export interface KotlinSpringReactiveWebClientGenerator<TOutput extends Output = Output> {
-  generate(ctx: Context): MaybePromise<TOutput>;
-}
-
-export class DefaultKotlinSpringReactiveWebClientGenerator extends KotlinFileGenerator<Context, Output>
-  implements KotlinSpringReactiveWebClientGenerator {
-  public generate(ctx: Context): MaybePromise<Output> {
-    const typeName = this.getRequestsObjectName(ctx, {});
-    const packageName = this.getPackageName(ctx, {});
-    const filePath = this.getFilePath(ctx, { packageName });
-
-    console.log(`Generating client for service ${ctx.service.name} to ${filePath}...`);
-    ctx.service.endpoints.forEach((endpoint) => {
-      console.log(
-        `  ${getSourceDisplayName(ctx.data, endpoint)} [${toCasing(endpoint.name, ctx.config.functionNameCasing)}]`,
-      );
-    });
-
-    const builder = new KotlinFileBuilder(packageName, ctx.config);
-    builder.append(this.getClientFileContent(ctx, {}));
-    builder.writeToFile(filePath);
-
-    return { typeName, packageName };
-  }
-
-  // deno-lint-ignore no-unused-vars
-  protected getClientFileContent(ctx: Context, args: Args.GetClientFileContent): AppendValueGroup<Builder> {
-    return appendValueGroup([this.getRequestsObject(ctx, {})], '\n\n');
-  }
-
-  // deno-lint-ignore no-unused-vars
-  protected getRequestsObject(ctx: Context, args: Args.GetRequestsObject): kt.Object<Builder> {
-    return kt.object({
-      name: this.getRequestsObjectName(ctx, {}),
-      members: ctx.service.endpoints.flatMap((endpoint) =>
-        this.getEndpointMembers(ctx, { endpoint, parameters: this.getAllParameters(ctx, { endpoint }) })
-      ),
-    });
-  }
-
-  protected getEndpointMembers(ctx: Context, args: Args.GetEndpointMembers): kt.ObjectMember<Builder>[] {
-    const { endpoint, parameters } = args;
-    const responseSchema = this.getResponseSchema(ctx, { endpoint });
-
-    return [
-      this.getEndpointFunction(ctx, { endpoint, parameters, responseSchema }),
-      this.getEndpointFunctionWithHandler(ctx, { endpoint, parameters, responseSchema }),
-      this.getEndpointUriFunction(ctx, { endpoint, parameters }),
-      this.getEndpointRequestFunction(ctx, { endpoint, parameters, responseSchema }),
-    ];
-  }
-
-  protected getEndpointFunctionName(ctx: Context, args: Args.GetEndpointFunctionName): string {
-    const { endpoint } = args;
-    return toCasing(endpoint.name, ctx.config.functionNameCasing);
-  }
-
-  protected getEndpointFunction(ctx: Context, args: Args.GetEndpointFunction): kt.Function<Builder> {
-    const { endpoint, parameters, responseSchema } = args;
-    const functionName = this.getEndpointFunctionName(ctx, { endpoint });
-
-    return kt.function(functionName, {
-      doc: kt.doc(this.getEndpointDocDescription(ctx, { endpoint })),
-      suspend: true,
-      receiverType: kt.refs.springReactive.webClient(),
-      parameters: parameters.map((parameter) =>
-        kt.parameter(
-          toCasing(parameter.name, ctx.config.parameterNameCasing),
-          this.getParameterType(ctx, { endpoint, parameter }),
-          { default: this.getParameterDefaultValue(ctx, { endpoint, parameter }) },
-        )
-      ),
-      returnType: this.getTypeUsage(ctx, { schema: responseSchema, fallback: kt.refs.unit() }),
-      body: this.getEndpointFunctionBody(ctx, { endpoint, parameters, responseSchema }),
-    });
-  }
-
-  protected getEndpointFunctionBody(ctx: Context, args: Args.GetEndpointFunctionBody): AppendValueGroup<Builder> {
-    const { endpoint, parameters, responseSchema } = args;
-    const result = appendValueGroup<Builder>([], '\n');
-
-    const requestFunctionName = this.getEndpointRequestFunctionName(ctx, { endpoint });
-    const parameterNames = parameters.map((p) => toCasing(p.name, ctx.config.parameterNameCasing));
-    const call = kt.call([
-      'this',
-      kt.call(requestFunctionName, parameterNames),
-      kt.call('retrieve', []),
-      responseSchema
-        ? kt.call(
-          kt.refs.springReactive.awaitBody([
-            this.getTypeUsage(ctx, { schema: responseSchema, fallback: kt.refs.unit() }),
-          ]),
-          [],
-        )
-        : kt.call(kt.refs.springReactive.awaitBodilessEntity(), []),
-    ]);
-
-    if (responseSchema) {
-      result.values.push(s`return ${call}`);
-    } else {
-      result.values.push(call);
-    }
-
-    return result;
-  }
-
-  protected getEndpointFunctionWithHandler(
-    ctx: Context,
-    args: Args.GetEndpointFunctionWithHandler,
-  ): kt.Function<Builder> {
-    const { endpoint, parameters, responseSchema } = args;
-    const functionName = this.getEndpointFunctionName(ctx, { endpoint });
-
-    return kt.function(functionName, {
-      doc: kt.doc(this.getEndpointDocDescription(ctx, { endpoint })),
-      suspend: true,
-      // Spring 7's `WebClient.awaitExchange` is `<V : Any>`, so the `<T>` overloads need an `Any` bound to infer.
-      generics: [
-        kt.genericParameter('T', ctx.config.springBootVersion === 4 ? { constraint: kt.refs.any() } : undefined),
-      ],
-      receiverType: kt.refs.springReactive.webClient(),
-      parameters: [
-        ...parameters.map((parameter) =>
-          kt.parameter(
-            toCasing(parameter.name, ctx.config.parameterNameCasing),
-            this.getParameterType(ctx, { endpoint, parameter }),
-            { default: this.getParameterDefaultValue(ctx, { endpoint, parameter }) },
-          )
-        ),
-        kt.parameter(
-          'responseHandler',
-          kt.lambdaType([kt.refs.springReactive.clientResponse()], 'T', { suspend: true }),
-        ),
-      ],
-      returnType: 'T',
-      body: this.getEndpointFunctionWithHandlerBody(ctx, { endpoint, parameters, responseSchema }),
-    });
-  }
-
-  protected getEndpointFunctionWithHandlerBody(
-    ctx: Context,
-    args: Args.GetEndpointFunctionWithHandlerBody,
-  ): AppendValueGroup<Builder> {
-    const { endpoint, parameters } = args;
-    const result = appendValueGroup<Builder>([], '\n');
-
-    const requestFunctionName = this.getEndpointRequestFunctionName(ctx, { endpoint });
-    const parameterNames = parameters.map((p) => toCasing(p.name, ctx.config.parameterNameCasing));
-
-    result.values.push(s`return ${
-      kt.call([
-        kt.call(['this', requestFunctionName], parameterNames),
-        kt.call([kt.refs.springReactive.awaitExchange()], ['responseHandler']),
-      ])
-    }`);
-
-    return result;
-  }
-
-  protected getEndpointRequestFunctionName(ctx: Context, args: Args.GetEndpointRequestFunctionName): string {
-    const { endpoint } = args;
-    return toCasing(`${this.getEndpointFunctionName(ctx, { endpoint })}_request`, ctx.config.functionNameCasing);
-  }
-
-  protected getEndpointRequestFunction(ctx: Context, args: Args.GetEndpointRequestFunction): kt.Function<Builder> {
-    const { endpoint, parameters, responseSchema } = args;
-    const functionName = this.getEndpointRequestFunctionName(ctx, { endpoint });
-
-    return kt.function(functionName, {
-      doc: kt.doc(this.getEndpointDocDescription(ctx, { endpoint })),
-      receiverType: kt.refs.springReactive.webClient(),
-      parameters: parameters.map((parameter) =>
-        kt.parameter(
-          toCasing(parameter.name, ctx.config.parameterNameCasing),
-          this.getParameterType(ctx, { endpoint, parameter }),
-          { default: this.getParameterDefaultValue(ctx, { endpoint, parameter }) },
-        )
-      ),
-      returnType: kt.refs.springReactive.requestHeadersSpec(['*']),
-      body: this.getEndpointRequestFunctionBody(ctx, { endpoint, parameters, responseSchema }),
-    });
-  }
-
-  protected getEndpointRequestFunctionBody(
-    ctx: Context,
-    args: Args.GetEndpointRequestFunctionBody,
-  ): AppendValueGroup<Builder> {
-    const { endpoint, parameters, responseSchema } = args;
-    const result = appendValueGroup<Builder>([], '\n');
-
-    const callChain: KtValue<Builder>[] = [];
-    callChain.push(
-      s`return this.method(${kt.refs.spring.httpMethod()}.${endpoint.method.toUpperCase()})`,
-      this.getEndpointUriCall(ctx, { endpoint, parameters }),
-    );
-
-    if (responseSchema) {
-      callChain.push(s`accept(${kt.refs.spring.mediaType()}.APPLICATION_JSON)`);
-    }
-
-    if (endpoint.requestBody?.content[0] !== undefined) {
-      callChain.push(
-        s`contentType(${kt.refs.spring.mediaType()}.parseMediaType(${
-          kt.string(endpoint.requestBody.content[0].type)
-        }))`,
-      );
-    }
-
-    if (endpoint.requestBody?.content[0]) {
-      if (endpoint.requestBody.content[0].type === 'multipart/form-data') {
-        callChain.push(
-          kt.call('body', [
-            kt.call([kt.refs.springReactive.bodyInserters(), 'fromMultipartData'], [
-              kt.call([
-                kt.call(kt.refs.spring.multipartBodyBuilder(), []),
-                kt.call('apply', [
-                  kt.lambda(
-                    [],
-                    appendValueGroup(
-                      parameters.filter((x) => x.multipart).map((p) => {
-                        const parameterName = toCasing(p.name, ctx.config.parameterNameCasing);
-                        if (p.multipart?.isFile) {
-                          return kt.call([
-                            p.required && !p.schema?.nullable ? parameterName : `${parameterName}?`,
-                            'addToBuilder',
-                          ], ['this']);
-                        } else {
-                          const call = kt.call([
-                            kt.call('part', [kt.string(p.multipart!.name), parameterName]),
-                            kt.call('contentType', [
-                              kt.call([
-                                kt.refs.spring.mediaType(),
-                                'APPLICATION_JSON',
-                              ]),
-                            ]),
-                          ]);
-                          return p.required && !p.schema?.nullable ? call : kt.call([`${parameterName}?`, 'also'], [
-                            kt.lambda([parameterName], call, { singleline: true }),
-                          ]);
-                        }
-                      }),
-                      '\n',
-                    ),
-                  ),
-                ]),
-                'build',
-              ], []),
-            ]),
-          ]),
-        );
-      } else {
-        const bodySchema = endpoint.requestBody.content[0].schema;
-        const parameterName = this.getRequestBodyParamName(ctx, { endpoint });
-        const call = kt.call('bodyValue', [
-          toCasing(parameterName, ctx.config.parameterNameCasing),
-        ]);
-        callChain.push(
-          endpoint.requestBody.required && !bodySchema?.nullable ? call : kt.call('apply', [
-            kt.lambda(
-              [],
-              kt.call([`${parameterName}?`, 'also'], [kt.lambda([parameterName], call, { singleline: true })]),
-              { singleline: true },
-            ),
-          ]),
-        );
-      }
-    }
-
-    if (parameters.some((x) => x.target === 'header')) {
-      callChain.push(
-        kt.call('headers', [
-          kt.lambda(
-            ['headers'],
-            appendValueGroup(
-              parameters.filter((x) => x.target === 'header').map((p) => {
-                const parameterName = toCasing(p.name, ctx.config.parameterNameCasing);
-                const toString = this.getParameterToString(ctx, { endpoint, parameter: p });
-                return p.required && !p.schema?.nullable
-                  ? kt.call(['headers', 'add'], [kt.string(p.name), s<Builder>`${parameterName}${toString}`])
-                  : kt.call([`${parameterName}?`, 'also'], [
-                    kt.lambda([], kt.call(['headers', 'add'], [kt.string(p.name), s<Builder>`it${toString}`]), {
-                      singleline: true,
-                    }),
-                  ]);
-              }),
-              '\n',
-            ),
-          ),
-        ]),
-      );
-    }
-
-    result.values.push(kt.call(callChain));
-    return result;
-  }
-
-  /**
-   * Emits the `uri(...)` call of the request function. If `preserveUriTemplate` is enabled, the URI template is
-   * passed to `WebClient` verbatim, so Spring can record it (`ClientRequestObservationContext.uriTemplate`) and tag
-   * `http.client.requests` with the route instead of the expanded path.
-   */
-  protected getEndpointUriCall(ctx: Context, args: Args.GetEndpointUriCall): kt.Value<Builder> {
-    const { endpoint, parameters } = args;
-
-    if (!ctx.config.preserveUriTemplate) {
-      return kt.call('uri', [kt.call(
-        [this.getEndpointUriFunctionName(ctx, { endpoint })],
-        parameters.filter((p) => p.target === 'path' || p.target === 'query').map((p) =>
-          toCasing(p.name, ctx.config.parameterNameCasing)
-        ),
-      )]);
-    }
-
-    const uriTemplate = kt.string(this.getEndpointPath(ctx, { endpoint }));
-    const pathVariables = this.getUriPathVariablesValue(ctx, { endpoint });
-    const queryParameterCalls = this.getUriQueryParameterCalls(ctx, { endpoint });
-
-    // Without query parameters the template and its variables can be handed to `uri` directly.
-    if (!queryParameterCalls) {
-      return kt.call('uri', [uriTemplate, pathVariables]);
-    }
-
-    // Query parameters need a `UriBuilder`, which the `uri(String, Function<UriBuilder, URI>)` overload provides
-    // while still recording the template.
-    return kt.call('uri', [
-      uriTemplate,
-      kt.lambda(
-        ['uriBuilder'],
-        kt.call([
-          'uriBuilder',
-          kt.call('apply', [kt.lambda([], queryParameterCalls)]),
-          kt.call('build', [pathVariables]),
-        ]),
-      ),
-    ]);
-  }
-
-  protected getUriPathVariablesValue(ctx: Context, args: Args.GetUriPathVariablesValue): kt.Value<Builder> | null {
-    const { endpoint } = args;
-    const pathParameters = endpoint.parameters.filter((p) => p.target === 'path');
-    if (pathParameters.length === 0) return null;
-
-    return kt.call(
-      [kt.refs.mapOf.infer()],
-      pathParameters.map((p) =>
-        s`${kt.string(p.name)} to ${toCasing(p.name, ctx.config.parameterNameCasing)}${
-          this.getParameterToString(ctx, { endpoint, parameter: p })
-        }`
-      ),
-    );
-  }
-
-  protected getUriQueryParameterCalls(
-    ctx: Context,
-    args: Args.GetUriQueryParameterCalls,
-  ): AppendValueGroup<Builder> | null {
-    const { endpoint } = args;
-    const queryParameters = endpoint.parameters.filter((p) => p.target === 'query');
-    if (queryParameters.length === 0) return null;
-
-    return appendValueGroup(
-      queryParameters.map((p) => {
-        const parameterName = toCasing(p.name, ctx.config.parameterNameCasing);
-        const toString = this.getParameterToString(ctx, { endpoint, parameter: p });
-        return p.required && !p.schema?.nullable
-          ? kt.call('queryParam', [kt.string(p.name), s<Builder>`${parameterName}${toString}`])
-          : kt.call([`${parameterName}?`, 'also'], [
-            kt.lambda([], kt.call('queryParam', [kt.string(p.name), s<Builder>`it${toString}`]), {
-              singleline: true,
-            }),
-          ]);
-      }),
-      '\n',
-    );
-  }
-
-  protected getEndpointUriFunctionName(ctx: Context, args: Args.GetEndpointUriFunctionName): string {
-    const { endpoint } = args;
-    return toCasing(`${this.getEndpointFunctionName(ctx, { endpoint })}_uri`, ctx.config.functionNameCasing);
-  }
-
-  protected getEndpointUriFunction(ctx: Context, args: Args.GetEndpointUriFunction): kt.Function<Builder> {
-    const { endpoint, parameters } = args;
-    const functionName = this.getEndpointUriFunctionName(ctx, { endpoint });
-
-    return kt.function(functionName, {
-      parameters: parameters.filter((p) => p.target === 'path' || p.target === 'query').map((parameter) =>
-        kt.parameter(
-          toCasing(parameter.name, ctx.config.parameterNameCasing),
-          this.getParameterType(ctx, { endpoint, parameter }),
-          { default: this.getParameterDefaultValue(ctx, { endpoint, parameter }) },
-        )
-      ),
-      returnType: kt.refs.string(),
-      body: this.getEndpointUriFunctionBody(ctx, { endpoint, parameters }),
-    });
-  }
-
-  protected getEndpointUriFunctionBody(ctx: Context, args: Args.GetEndpointUriFunctionBody): AppendValueGroup<Builder> {
-    const { endpoint } = args;
-    const result = appendValueGroup<Builder>([], '\n');
-
-    const callChain: KtValue<Builder>[] = [];
-    callChain.push(
-      s`${kt.refs.spring.uriComponentsBuilder()}.fromPath(${kt.string(this.getEndpointPath(ctx, { endpoint }))})`,
-    );
-
-    const queryParameterCalls = this.getUriQueryParameterCalls(ctx, { endpoint });
-    if (queryParameterCalls) {
-      callChain.push(kt.call('apply', [kt.lambda([], queryParameterCalls)]));
-    }
-
-    const pathVariables = this.getUriPathVariablesValue(ctx, { endpoint });
-    callChain.push(pathVariables ? kt.call('buildAndExpand', [pathVariables]) : kt.call('build', []));
-
-    callChain.push('toUriString');
-    result.values.push(s`return ${kt.call(callChain, [])}`);
-    return result;
-  }
-
-  protected getParameterToString(ctx: Context, args: Args.GetParameterToString): kt.Value<Builder> {
-    const { parameter } = args;
-    if (parameter.schema?.kind === 'array') {
-      const itemEnumSchema = getArrayItemStringEnumSchema(parameter.schema);
-      const itemEnumType = itemEnumSchema && this.getSchemaType(ctx, { schema: itemEnumSchema });
-      return itemEnumType ? s`.joinToString(",", transform = ${itemEnumType}::value)` : '.joinToString(",")';
-    } else if (
-      getStringEnumSchema(parameter.schema) && this.getSchemaType(ctx, { schema: parameter.schema })
-    ) {
-      return '.value';
-    } else {
-      return '.toString()';
-    }
-  }
-
-  protected getParameterType(ctx: Context, args: Args.GetParameterType): kt.Type<Builder> {
-    const { parameter } = args;
-    if (parameter.multipart?.isFile) {
-      return ctx.refs.apiRequestFile();
-    }
-    return this.getTypeUsage(ctx, {
-      schema: parameter.schema,
-      nullable: !parameter.required,
-    });
-  }
-
-  protected getParameterDefaultValue(ctx: Context, args: Args.GetParameterDefaultValue): kt.Value<Builder> | null {
-    const { schema } = args.parameter;
-
-    if (args.parameter.required) {
-      return null;
-    }
-
-    if (getStringEnumSchema(schema) && schema?.default) {
-      return s`${this.getTypeUsage(ctx, { schema, nullable: false })}.${
-        toCasing(String(schema.default), ctx.config.enumValueNameCasing)
-      }`;
-    }
-
-    const itemEnumSchema = getArrayItemStringEnumSchema(schema);
-    if (itemEnumSchema && Array.isArray(schema?.default)) {
-      const itemType = this.getTypeUsage(ctx, { schema: itemEnumSchema, nullable: false });
-      return kt.call(
-        kt.refs.listOf.infer(),
-        schema.default.map((x) => s<Builder>`${itemType}.${toCasing(String(x), ctx.config.enumValueNameCasing)}`),
-      );
-    }
-
-    return kt.toNode(schema?.default);
-  }
-
-  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 }));
-  }
-
-  // deno-lint-ignore no-unused-vars
-  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 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' || parameter.target === 'header',
-    );
-    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 getEndpointDocDescription(ctx: Context, args: Args.GetEndpointDocDescription): BasicAppendValue<Builder> {
-    const docSegments = [args.endpoint.description?.trim()];
-
-    if (ctx.config.includeSourceInDocs) {
-      docSegments.push(getSourceDocLine(args.endpoint));
-    }
-
-    return docSegments.filter(notNullish).join('\n\n');
-  }
-
-  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.replace(/^\/*/, ''), ctx.config.pathModifier, endpoint);
-  }
-
-  protected getFilePath(ctx: Context, args: Args.GetFilePath): string {
-    const { packageName } = args;
-    return `${ctx.config.outputDir}/${packageName.replace(/\./g, '/')}/${this.getRequestsObjectName(ctx, {})}.kt`;
-  }
-
-  // deno-lint-ignore no-unused-vars
-  protected getRequestsObjectName(ctx: Context, args: Args.GetRequestsObjectName): string {
-    return toCasing(`${ctx.service.name}_Requests`, ctx.config.typeNameCasing);
-  }
-
-  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,
-    };
-  }
-}