@goast/typescript 0.5.3 → 0.6.0-beta.1

package/src/src/generators/services/angular-services/angular-service-generator.ts

@@ -1,406 +0,0 @@
-import { resolve } from 'node:path';
-
-import {
-  type ApiEndpoint,
-  type ApiResponse,
-  type ApiSchema,
-  type AppendValueGroup,
-  appendValueGroup,
-  builderTemplate as s,
-  type MaybePromise,
-  type Nullable,
-  toCasing,
-} from '@goast/core';
-
-import { ts } from '../../../ast/index.js';
-import type { TypeScriptExportOutput } from '../../../common-results.js';
-import { TypeScriptFileBuilder } from '../../../file-builder.js';
-import { TypeScriptFileGenerator } from '../../file-generator.js';
-import type { TypeScriptAngularServiceGeneratorContext, TypeScriptAngularServiceGeneratorOutput } from './models.js';
-
-type Context = TypeScriptAngularServiceGeneratorContext;
-type Output = TypeScriptAngularServiceGeneratorOutput;
-type Builder = TypeScriptFileBuilder;
-
-export interface TypeScriptAngularServiceGenerator<TOutput extends Output = Output> {
-  generate(ctx: Context): MaybePromise<TOutput>;
-}
-
-export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGenerator<Context, Output>
-  implements TypeScriptAngularServiceGenerator {
-  public generate(ctx: Context): MaybePromise<Output> {
-    const responseModels = this.generateResponseModels(ctx);
-
-    const filePath = this.getServiceFilePath(ctx);
-    const name = this.getServiceClassName(ctx);
-
-    TypeScriptFileBuilder.generate({
-      logName: `service ${name}`,
-      filePath,
-      options: ctx.config,
-      generator: (b) => b.append(this.getServiceFileContent(ctx)),
-    });
-
-    return {
-      filePath,
-      component: name,
-      responseModels,
-    };
-  }
-
-  // #region Response Model
-  protected generateResponseModels(ctx: Context): Record<string, TypeScriptExportOutput> {
-    const result: Record<string, TypeScriptExportOutput> = {};
-    const filePath = this.getResponseModelFilePath(ctx);
-    const builder = new TypeScriptFileBuilder(filePath, ctx.config);
-
-    for (const endpoint of ctx.service.endpoints) {
-      const name = this.getResponseModelName(ctx, endpoint);
-      builder.appendLine(this.getResponseModelFileContent(ctx, endpoint));
-      result[endpoint.id] = { component: name, filePath };
-    }
-
-    builder.writeToFile();
-    return result;
-  }
-
-  protected getResponseModelFileContent(ctx: Context, endpoint: ApiEndpoint): AppendValueGroup<Builder> {
-    const result = appendValueGroup<Builder>([]);
-    const statusCodes = this.getEndpointStatusCodes(ctx, endpoint);
-    let statusCodeType: ts.Reference<Builder>;
-
-    const statusCodesTypeName = toCasing(`${endpoint.name}_StatusCodes`, ctx.config.typeNameCasing);
-    result.values.push(ts.typeAlias(statusCodesTypeName, ts.unionType(Object.keys(statusCodes))));
-    if (ctx.config.strictResponseTypes) {
-      statusCodeType = ts.reference(statusCodesTypeName);
-    } else {
-      statusCodeType = ctx.refs.httpStatusCode();
-    }
-
-    result.values.push(
-      ts.typeAlias(
-        this.getResponseModelName(ctx, endpoint),
-        ts.intersectionType([
-          ts.unionType([
-            ...Object.entries(statusCodes).map(([key, value]) => {
-              const isSuccess = key.startsWith('2');
-              return ts.intersectionType<Builder>([
-                isSuccess
-                  ? ts.refs.angular.httpResponse([value.type])
-                  : ts.refs.omit([ts.refs.angular.httpErrorResponse(), ts.string('error')]),
-                ts.objectType({
-                  members: [
-                    isSuccess ? null : ts.property('error', { type: ts.unionType([value.type, ts.refs.null_()]) }),
-                    ts.property('status', { type: key }),
-                    ts.property('ok', { type: isSuccess ? 'true' : 'false' }),
-                  ],
-                }),
-              ]);
-            }),
-            !ctx.config.strictResponseTypes
-              ? ts.intersectionType([
-                ts.refs.angular.httpResponse([this.getAnyType(ctx)]),
-                ts.objectType({
-                  members: [
-                    ts.property('status', {
-                      type: ts.refs.exclude([ctx.refs.httpStatusCode(), ts.reference(statusCodesTypeName)]),
-                    }),
-                  ],
-                }),
-              ])
-              : null,
-          ]),
-          ts.objectType({ members: [ts.property('status', { type: 'TStatus' })] }),
-        ]),
-        {
-          doc: ts.doc({
-            description: `Response model for operation ${this.getEndpointMethodName(ctx, endpoint)}`,
-            tags: [endpoint.deprecated ? ts.docTag('deprecated') : null],
-          }),
-          export: true,
-          generics: [
-            ts.genericParameter('TStatus', {
-              constraint: statusCodeType,
-              default: statusCodeType,
-            }),
-          ],
-        },
-      ),
-    );
-
-    return result;
-  }
-
-  protected getEndpointStatusCodes(
-    ctx: Context,
-    endpoint: ApiEndpoint,
-  ): Record<number, { parser: 'text' | 'json'; type: ts.Type<Builder> }> {
-    return Object.fromEntries([
-      ...Object.entries(ctx.config.defaultStatusCodeResponseTypes).map(([key, value]) => [
-        key,
-        {
-          parser: value?.parser ?? 'text',
-          type: typeof value?.type === 'function'
-            ? this.getSchemaType(ctx, value.type(ctx.data.schemas))
-            : value ?? this.getAnyType(ctx),
-        },
-      ]),
-      ...endpoint.responses
-        .filter((x) => x.statusCode)
-        .map((x) => [
-          x.statusCode,
-          {
-            parser: this.contentTypeToResponseType(x.contentOptions[0]?.type),
-            type: this.getSchemaType(ctx, x.contentOptions[0]?.schema, this.getAnyType(ctx)),
-          },
-        ]),
-    ]);
-  }
-  // #endregion
-
-  protected getServiceFileContent(ctx: Context): AppendValueGroup<Builder> {
-    const code = appendValueGroup<Builder>([], '\n');
-    for (const endpoint of ctx.service.endpoints) {
-      if (endpoint.parameters.length > 0 || endpoint.requestBody !== undefined) {
-        code.values.push(this.getEndpointParamsType(ctx, endpoint));
-      }
-    }
-    code.values.push(this.getClass(ctx));
-    return code;
-  }
-
-  protected getEndpointParamsType(ctx: Context, endpoint: ApiEndpoint): ts.TypeAlias<Builder> {
-    const type = ts.objectType<Builder>();
-
-    for (const parameter of endpoint.parameters) {
-      const schema = parameter.schema;
-      type.members.push(
-        ts.property(toCasing(parameter.name, ctx.config.propertyNameCasing), {
-          doc: ts.doc({
-            description: parameter.description,
-            tags: [parameter.deprecated ? ts.docTag('deprecated') : null],
-          }),
-          type: schema ? (b) => b.appendModelUsage(ctx.input.typescript.models[schema.id]) : this.getAnyType(ctx),
-          optional: !parameter.required,
-        }),
-      );
-    }
-
-    if (endpoint.requestBody !== undefined) {
-      const body = endpoint.requestBody;
-      const schema = body.content[0].schema;
-      type.members.push(
-        ts.property('body', {
-          doc: ts.doc({ description: body.description }),
-          type: schema ? (b) => b.appendModelUsage(ctx.input.typescript.models[schema.id]) : this.getAnyType(ctx),
-          optional: !body.required,
-        }),
-      );
-    }
-
-    return ts.typeAlias(this.getEndpointParamsTypeName(ctx, endpoint), type, {
-      doc: ts.doc({ description: `Parameters for operation ${this.getEndpointMethodName(ctx, endpoint)}` }),
-    });
-  }
-
-  protected getClass(ctx: Context): ts.Class<Builder> {
-    return ts.class<Builder>(this.getServiceClassName(ctx), {
-      doc: ts.doc({
-        description: ctx.service.description,
-        tags: [
-          ctx.service.endpoints.length === 0 || ctx.service.endpoints.some((x) => !x.deprecated)
-            ? null
-            : ts.docTag('deprecated'),
-        ],
-      }),
-      decorators: [
-        ts.decorator(
-          ts.refs.angular.injectable(),
-          ctx.config.provideKind === 'root' ? [ts.toNode({ providedIn: 'root' })] : [],
-        ),
-      ],
-      export: true,
-      extends: ctx.refs.apiBaseService(),
-      members: [
-        ...ctx.service.endpoints.map((e) =>
-          ts.property(this.getEndpointPathPropertyName(ctx, e), {
-            accessModifier: 'private',
-            static: true,
-            readonly: true,
-            value: ts.string(e.path),
-          })
-        ),
-        ...ctx.service.endpoints.map((e) => this.getEndpointMethod(ctx, e)),
-      ],
-    });
-  }
-
-  protected getEndpointMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder> {
-    const hasParams = this.hasEndpointParams(ctx, endpoint);
-    const paramsOptional = !endpoint.parameters.some((p) => p.required) && !endpoint.requestBody?.required;
-    const responseModelType = ts.reference(
-      this.getResponseModelName(ctx, endpoint),
-      this.getResponseModelFilePath(ctx),
-      {
-        importType: 'type-import',
-      },
-    );
-    const returnType = ctx.refs.abortablePromise([responseModelType]);
-    const accept = this.getEndpointSuccessResponseType(ctx, endpoint);
-    const responseType = this.contentTypeToResponseType(accept);
-    return ts.method<Builder>(this.getEndpointMethodName(ctx, endpoint), {
-      accessModifier: 'public',
-      parameters: [
-        hasParams
-          ? ts.parameter('params', {
-            optional: paramsOptional,
-            type: ts.reference(this.getEndpointParamsTypeName(ctx, endpoint)),
-          })
-          : null,
-        ts.parameter('context', { optional: true, type: ts.refs.angular.httpContext() }),
-      ],
-      doc: ts.doc({
-        description: endpoint.description,
-        tags: [endpoint.deprecated ? ts.docTag('deprecated') : null],
-      }),
-      returnType,
-      body: appendValueGroup(
-        [
-          s`const rb = new ${ctx.refs.requestBuilder()}(this.rootUrl, ${
-            this.getServiceClassName(
-              ctx,
-            )
-          }.${this.getEndpointPathPropertyName(ctx, endpoint)}, '${endpoint.method}');`,
-          hasParams
-            ? (b) =>
-              b.appendIf(paramsOptional, 'if (params) ').parenthesizeIf(
-                paramsOptional,
-                '{}',
-                appendValueGroup(
-                  [
-                    ...endpoint.parameters
-                      .filter((p) => p.target === 'path' || p.target === 'query' || p.target === 'header')
-                      .map((p) => {
-                        const options = ts.object({
-                          members: [
-                            p.style !== undefined ? ts.property('style', { value: ts.string(p.style) }) : null,
-                            p.explode !== undefined ? ts.property('explode', { value: ts.toNode(p.explode) }) : null,
-                          ],
-                        });
-                        return s<Builder>`rb.${p.target}(${ts.string(p.name)}, params.${
-                          toCasing(
-                            p.name,
-                            ctx.config.propertyNameCasing,
-                          )
-                        }, ${options});`;
-                      }),
-                    endpoint.requestBody
-                      ? s`rb.body(params.body, ${ts.string(this.getEndpointRequestContentType(ctx, endpoint))});`
-                      : null,
-                  ],
-                  '\n',
-                ),
-                { multiline: true },
-              )
-            : null,
-          '',
-          s`return ${ctx.refs.waitForResponse([responseModelType])}(${s.indent`
-              this.http.request(rb.build({${s.indent`
-                responseType: ${ts.string(responseType)},
-                accept: ${ts.string(accept)},
-                context,`}
-              })),
-              {${s.indent`
-                errorResponseTypes: ${
-            ts.object({
-              members: [
-                ...Object.entries(this.getEndpointStatusCodes(ctx, endpoint))
-                  .filter(([key]) => !key.startsWith('2'))
-                  .map(([key, value]) => {
-                    return ts.property(key, { value: ts.string(value.parser) });
-                  }),
-              ],
-            })
-          }`}
-              }`}
-            )`,
-        ],
-        '\n',
-      ),
-    });
-  }
-
-  protected getEndpointRequestContentType(ctx: Context, endpoint: ApiEndpoint): string {
-    return ctx.config.defaultRequestContentType ?? endpoint?.requestBody?.content[0].type ?? 'application/json';
-  }
-
-  protected getEndpointSuccessResponseType(ctx: Context, endpoint: ApiEndpoint): string {
-    const response = this.getEndpointSuccessResponse(ctx, endpoint);
-    if (!response) return '*/*';
-
-    if (!ctx.config.defaultSuccessResponseContentType) return response.contentOptions[0]?.type ?? '*/*';
-
-    return (
-      response.contentOptions.find((x) => x.type === ctx.config.defaultSuccessResponseContentType)?.type ??
-        response.contentOptions[0]?.type ??
-        '*/*'
-    );
-  }
-
-  protected getEndpointSuccessResponse(_ctx: Context, endpoint: ApiEndpoint): ApiResponse | undefined {
-    return (
-      endpoint.responses.find((x) => x.statusCode && x.statusCode >= 200 && x.statusCode < 300) ??
-        endpoint.responses.find((x) => x.statusCode === undefined)
-    );
-  }
-
-  protected getServiceClassName(ctx: Context): string {
-    return toCasing(ctx.service.name + '_Service', ctx.config.typeNameCasing);
-  }
-
-  protected getResponseModelName(ctx: Context, endpoint: ApiEndpoint): string {
-    return toCasing(`${this.getEndpointMethodName(ctx, endpoint)}ApiResponse`, ctx.config.typeNameCasing);
-  }
-
-  protected getEndpointParamsTypeName(ctx: Context, endpoint: ApiEndpoint): string {
-    return toCasing(this.getEndpointMethodName(ctx, endpoint) + '_Params', ctx.config.typeNameCasing);
-  }
-
-  protected getEndpointPathPropertyName(ctx: Context, endpoint: ApiEndpoint): string {
-    return toCasing(this.getEndpointMethodName(ctx, endpoint) + '_Path', ctx.config.constantNameCasing);
-  }
-
-  protected getEndpointMethodName(ctx: Context, endpoint: ApiEndpoint): string {
-    return toCasing(endpoint.name, ctx.config.functionNameCasing);
-  }
-
-  protected getServiceFilePath(ctx: Context): string {
-    return resolve(
-      ctx.config.outputDir,
-      ctx.config.servicesDir,
-      `${toCasing(ctx.service.name, ctx.config.serviceFileNameCasing ?? ctx.config.fileNameCasing)}.ts`,
-    );
-  }
-
-  protected getResponseModelFilePath(ctx: Context): string {
-    return resolve(
-      ctx.config.outputDir,
-      ctx.config.responseModelsDir,
-      `${toCasing(ctx.service.name, ctx.config.responseModelFileNameCasing ?? ctx.config.fileNameCasing)}.ts`,
-    );
-  }
-
-  protected hasEndpointParams(_ctx: Context, endpoint: ApiEndpoint): boolean {
-    return endpoint.parameters.length > 0 || endpoint.requestBody !== undefined;
-  }
-
-  protected getSchemaType(ctx: Context, schema: ApiSchema | undefined, fallback?: ts.Type<Builder>): ts.Type<Builder> {
-    const output = schema && ctx.input.typescript.models[schema.id];
-    if (!output) return fallback ?? this.getAnyType(ctx);
-    return (b) => b.appendModelUsage(output);
-  }
-
-  private contentTypeToResponseType(contentType: Nullable<string>): 'text' | 'json' {
-    return contentType?.includes('json') ? 'json' : 'text';
-  }
-}

package/src/src/generators/services/angular-services/angular-services-generator.ts

@@ -1,295 +0,0 @@
-import { resolve } from 'node:path';
-
-
-import fs from 'fs-extra';
-
-import {
-  type ApiService,
-  type AppendValueGroup,
-  appendValueGroup,
-  Factory,
-  type MaybePromise,
-  type OpenApiGeneratorContext,
-  OpenApiServicesGenerationProviderBase,
-  toCasing,
-} from '@goast/core';
-
-import { copyAssetFile } from '../../../assets.js';
-import { ts } from '../../../ast/index.js';
-import { TypeScriptFileBuilder } from '../../../file-builder.js';
-import { modifyString } from '../../../utils.js';
-import {
-  DefaultTypeScriptAngularServiceGenerator,
-  type TypeScriptAngularServiceGenerator,
-} from './angular-service-generator.js';
-import {
-  defaultTypeScriptAngularServicesGeneratorConfig,
-  type TypeScriptAngularServiceGeneratorOutput,
-  type TypeScriptAngularServicesGeneratorConfig,
-  type TypeScriptAngularServicesGeneratorContext,
-  type TypeScriptAngularServicesGeneratorInput,
-  type TypeScriptAngularServicesGeneratorOutput,
-} from './models.js';
-import { getReferenceFactories } from './refs.js';
-
-type Input = TypeScriptAngularServicesGeneratorInput;
-type Output = TypeScriptAngularServicesGeneratorOutput;
-type Config = TypeScriptAngularServicesGeneratorConfig;
-type ServiceOutput = TypeScriptAngularServiceGeneratorOutput;
-type Context = TypeScriptAngularServicesGeneratorContext;
-
-export class TypeScriptAngularServicesGenerator extends OpenApiServicesGenerationProviderBase<
-  Input,
-  Output,
-  Config,
-  ServiceOutput,
-  Context
-> {
-  private readonly _clientGeneratorFactory: Factory<TypeScriptAngularServiceGenerator, []>;
-
-  constructor(clientGeneratorFactory?: Factory<TypeScriptAngularServiceGenerator, []>) {
-    super();
-    this._clientGeneratorFactory = clientGeneratorFactory ??
-      Factory.fromValue(new DefaultTypeScriptAngularServiceGenerator());
-  }
-
-  protected override initResult(): Output {
-    return {
-      typescript: {
-        services: {},
-        indexFiles: { services: undefined, responseModels: undefined },
-      },
-    };
-  }
-
-  protected override buildContext(
-    context: OpenApiGeneratorContext<Input>,
-    config?: Partial<Config> | undefined,
-  ): Context {
-    const providerContext = this.getProviderContext(context, config, defaultTypeScriptAngularServicesGeneratorConfig);
-    return Object.assign(providerContext, {
-      refs: getReferenceFactories(providerContext.config),
-    });
-  }
-
-  protected override async generateAdditionalFiles(ctx: TypeScriptAngularServicesGeneratorContext): Promise<void> {
-    await this.generateUtilsFiles(ctx);
-    ctx.output.typescript.indexFiles = this.generateIndexFiles(ctx);
-  }
-
-  protected override generateService(ctx: Context, service: ApiService): MaybePromise<ServiceOutput> {
-    const clientGenerator = this._clientGeneratorFactory.create();
-    return clientGenerator.generate({
-      ...ctx,
-      service,
-    });
-  }
-
-  protected override addServiceResult(ctx: Context, service: ApiService, result: ServiceOutput): void {
-    ctx.output.typescript.services[service.id] = result;
-  }
-
-  // #region Utils
-  protected async generateUtilsFiles(ctx: Context): Promise<void> {
-    const targetDir = resolve(ctx.config.outputDir, ctx.config.utilsDir);
-    await fs.ensureDir(targetDir);
-
-    await copyAssetFile('client/angular/request-builder.ts', targetDir, 'Request Builder');
-    await copyAssetFile('client/angular/angular-service.utils.ts', targetDir, 'Angular Service Utils');
-
-    TypeScriptFileBuilder.generate({
-      logName: 'api configuration',
-      filePath: resolve(targetDir, 'api-configuration.ts'),
-      options: ctx.config,
-      generator: (b) => b.append(this.getApiConfigurationFileContent(ctx)),
-    });
-
-    TypeScriptFileBuilder.generate({
-      logName: 'api base service',
-      filePath: resolve(targetDir, 'api-base-service.ts'),
-      options: ctx.config,
-      generator: (b) => b.append(this.getApiBaseServiceFileContent(ctx)),
-    });
-
-    if (!ctx.config.strictResponseTypes) {
-      TypeScriptFileBuilder.generate({
-        logName: 'http status codes',
-        filePath: resolve(targetDir, 'http-status-code.ts'),
-        options: ctx.config,
-        generator: (b) => b.append(this.getHttpStatusCodeFileContent(ctx)),
-      });
-    }
-
-    if (ctx.config.provideKind === 'provide-fn') {
-      TypeScriptFileBuilder.generate({
-        logName: 'providers',
-        filePath: resolve(targetDir, 'provide.ts'),
-        options: ctx.config,
-        generator: (b) => b.append(this.getProvideFnFileContent(ctx)),
-      });
-    }
-  }
-
-  protected getApiConfigurationFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      [
-        ts.class(toCasing(`${ctx.config.domainName ?? ''}ApiConfiguration`, ctx.config.typeNameCasing), {
-          doc: ts.doc({ description: `${ctx.config.domainName ?? 'Global'} API Configuration.` }),
-          decorators: [
-            ts.decorator(ts.refs.angular.injectable(), [
-              ctx.config.provideKind === 'root' ? ts.toNode({ providedIn: 'root' }) : null,
-            ]),
-          ],
-          export: true,
-          members: [
-            ts.property('rootUrl', {
-              accessModifier: 'public',
-              type: ts.refs.string(),
-              value: ts.string(this.getRootUrl(ctx)),
-            }),
-          ],
-        }),
-      ],
-      '\n',
-    );
-  }
-
-  protected getApiBaseServiceFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      [
-        ts.class('ApiBaseService', {
-          doc: ts.doc({ description: 'Base class for API services.' }),
-          export: true,
-          abstract: true,
-          members: [
-            ts.property('config', {
-              accessModifier: 'protected',
-              value: (b) => b.append(ts.refs.angular.inject(), '(', ctx.refs.apiConfiguration(), ')'),
-            }),
-            ts.property('http', {
-              accessModifier: 'protected',
-              value: (b) => b.append(ts.refs.angular.inject(), '(', ts.refs.angular.httpClient(), ')'),
-            }),
-            ts.property('_rootUrl', { accessModifier: 'private', type: ts.refs.string(), value: ts.string('') }),
-            ts.property('rootUrl', {
-              doc: ts.doc({
-                description:
-                  `Gets or sets the root URL for API operations provided by this service.\nFalls back to \`${ctx.refs.apiConfiguration.refName}.rootUrl\` if not set in this service.`,
-              }),
-              accessModifier: 'public',
-              type: ts.refs.string(),
-              get: ts.property.getter({ body: 'return this._rootUrl || this.config.rootUrl;' }),
-              set: ts.property.setter({ body: 'this._rootUrl = value;' }),
-            }),
-          ],
-        }),
-      ],
-      '\n',
-    );
-  }
-
-  protected getHttpStatusCodeFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      [
-        ts.typeAlias('HttpStatusCode', ts.unionType(ctx.config.possibleStatusCodes), {
-          doc: ts.doc({ description: 'The possible status codes that any API endpoint can return.' }),
-          export: true,
-        }),
-      ],
-      '\n',
-    );
-  }
-
-  protected getProvideFnFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      [
-        ts.function(toCasing(`provide_${ctx.config.domainName ?? ''}_Api`, ctx.config.functionNameCasing), {
-          doc: ts.doc({
-            description: 'Provides all the API services' +
-              (ctx.config.domainName ? ` for ${ctx.config.domainName}` : '') + '.',
-          }),
-          export: true,
-          parameters: [ts.parameter('config', { type: ctx.refs.apiConfiguration(), optional: true })],
-          returnType: ts.refs.angular.provider(),
-          body: appendValueGroup([
-            'return ',
-            ts.tuple([
-              (b) =>
-                b.append(
-                  'config ? { provide: ',
-                  ctx.refs.apiConfiguration(),
-                  ', useValue: config } : ',
-                  ctx.refs.apiConfiguration(),
-                ),
-              ...Object.values(ctx.output.typescript.services).map((x) => ts.reference(x.component, x.filePath)),
-            ]),
-            ';',
-          ]),
-        }),
-      ],
-      '\n',
-    );
-  }
-
-  protected getRootUrl(ctx: Context): string {
-    return modifyString<[]>(
-      (ctx.data.services[0].$src ?? ctx.data.services[0].endpoints[0]?.$src)?.document.servers?.[0]?.url ?? '/',
-      ctx.config.rootUrl,
-    );
-  }
-  // #endregion
-
-  // #region Index
-  protected generateIndexFiles(ctx: Context): Output['typescript']['indexFiles'] {
-    const servicesIndexFilePath = this.getServicesIndexFilePath(ctx);
-    const responseModelsIndexFilePath = this.getResponseModelsIndexFilePath(ctx);
-
-    TypeScriptFileBuilder.tryGenerate({
-      logName: 'services index file',
-      filePath: servicesIndexFilePath,
-      options: ctx.config,
-      generator: (b) => b.append(this.getServicesIndexFileContent(ctx)),
-    });
-
-    TypeScriptFileBuilder.tryGenerate({
-      logName: 'response models index file',
-      filePath: responseModelsIndexFilePath,
-      options: ctx.config,
-      generator: (b) => b.append(this.getResponseModelsIndexFileContent(ctx)),
-    });
-
-    return {
-      services: servicesIndexFilePath,
-      responseModels: responseModelsIndexFilePath,
-    };
-  }
-
-  protected getServicesIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup([
-      ts.export(ctx.refs.apiConfiguration.refName, ctx.refs.apiConfiguration.moduleNameOrfilePath),
-      ctx.config.provideKind === 'provide-fn'
-        ? ts.export(ctx.refs.provide.refName, ctx.refs.provide.moduleNameOrfilePath)
-        : null,
-      ...Object.values(ctx.output.typescript.services).map((x) => ts.export(x.component, x.filePath)),
-    ]);
-  }
-
-  protected getResponseModelsIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
-    return appendValueGroup(
-      Object.values(ctx.output.typescript.services)
-        .flatMap((x) => Object.values(x.responseModels))
-        .map((x) => ts.export(x.component, x.filePath, { kind: 'type-export' })),
-    );
-  }
-
-  protected getServicesIndexFilePath(ctx: Context): string | null {
-    return ctx.config.servicesIndexFile ? resolve(ctx.config.outputDir, ctx.config.servicesIndexFile) : null;
-  }
-
-  protected getResponseModelsIndexFilePath(ctx: Context): string | null {
-    return ctx.config.responseModelsIndexFile
-      ? resolve(ctx.config.outputDir, ctx.config.responseModelsIndexFile)
-      : null;
-  }
-  // #endregion
-}

package/src/src/generators/services/angular-services/index.ts

@@ -1,3 +0,0 @@
-export * from './angular-service-generator.js';
-export * from './angular-services-generator.js';
-export * from './models.js';