@goast/typescript 0.4.1-beta1 → 0.4.1

package/src/src/generators/models/models-generator.ts

@@ -0,0 +1,108 @@
+import { resolve } from 'node:path';
+
+import {
+  type ApiSchema,
+  type AppendValueGroup,
+  appendValueGroup,
+  Factory,
+  type MaybePromise,
+  type OpenApiGeneratorContext,
+  OpenApiSchemasGenerationProviderBase,
+} from '@goast/core';
+
+import { ts } from '../../ast/index.js';
+import { TypeScriptFileBuilder } from '../../file-builder.js';
+import { DefaultTypeScriptModelGenerator, type TypeScriptModelGenerator } from './model-generator.js';
+import {
+  defaultTypeScriptModelsGeneratorConfig,
+  type TypeScriptModelGeneratorOutput,
+  type TypeScriptModelsGeneratorConfig,
+  type TypeScriptModelsGeneratorContext,
+  type TypeScriptModelsGeneratorInput,
+  type TypeScriptModelsGeneratorOutput,
+} from './models.js';
+
+type Input = TypeScriptModelsGeneratorInput;
+type Output = TypeScriptModelsGeneratorOutput;
+type Config = TypeScriptModelsGeneratorConfig;
+type SchemaOutput = TypeScriptModelGeneratorOutput;
+type Context = TypeScriptModelsGeneratorContext;
+
+export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderBase<
+  Input,
+  Output,
+  Config,
+  SchemaOutput,
+  Context
+> {
+  private readonly _modelGeneratorFactory: Factory<TypeScriptModelGenerator, []>;
+
+  constructor(modelGeneratorFactory?: Factory<TypeScriptModelGenerator, []>) {
+    super();
+    this._modelGeneratorFactory = modelGeneratorFactory ?? Factory.fromValue(new DefaultTypeScriptModelGenerator());
+  }
+
+  protected override initResult(): Output {
+    return {
+      typescript: {
+        models: {},
+        indexFiles: { models: undefined },
+      },
+    };
+  }
+
+  protected override buildContext(
+    context: OpenApiGeneratorContext<TypeScriptModelsGeneratorInput>,
+    config?: Partial<Config> | undefined,
+  ): Context {
+    return this.getProviderContext(context, config, defaultTypeScriptModelsGeneratorConfig);
+  }
+
+  protected override generateAdditionalFiles(ctx: TypeScriptModelsGeneratorContext): MaybePromise<void> {
+    ctx.output.typescript.indexFiles.models = this.generateIndexFile(ctx);
+  }
+
+  protected override generateSchema(ctx: Context, schema: ApiSchema): MaybePromise<SchemaOutput> {
+    const modelGenerator = this._modelGeneratorFactory.create();
+    return modelGenerator.generate({
+      ...ctx,
+      schema,
+    });
+  }
+
+  protected override addSchemaResult(ctx: Context, schema: ApiSchema, result: SchemaOutput): void {
+    ctx.output.typescript.models[schema.id] = result;
+  }
+
+  protected generateIndexFile(ctx: Context): string | null {
+    const filePath = this.getIndexFilePath(ctx);
+    TypeScriptFileBuilder.tryGenerate({
+      logName: 'model index file',
+      filePath,
+      options: ctx.config,
+      generator: (b) => b.append(this.getIndexFileContent(ctx)),
+    });
+    return filePath;
+  }
+
+  protected getIndexFilePath(ctx: Context): string | null {
+    return ctx.config.modelsIndexFile ? resolve(ctx.config.outputDir, ctx.config.modelsIndexFile) : null;
+  }
+
+  protected getIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder> {
+    return appendValueGroup(
+      Object.values(ctx.output.typescript.models).flatMap((x) => {
+        const { filePath } = x;
+        if (!filePath) return [];
+        return [
+          ts.export(x.component, filePath, {
+            kind: x.kind === 'type' || x.kind === 'interface' ? 'type-export' : 'export',
+          }),
+          ...(x.additionalExports?.map((e) =>
+            typeof e === 'string' ? ts.export(e, filePath) : ts.export(e.name, filePath, { kind: e.type })
+          ) ?? []),
+        ];
+      }),
+    );
+  }
+}

package/src/src/generators/models/models.ts

@@ -0,0 +1,105 @@
+import type {
+  ApiSchema,
+  DefaultGenerationProviderConfig,
+  ExtendedStringCasing,
+  Nullable,
+  OpenApiSchemasGenerationProviderContext,
+} from '@goast/core';
+
+import type { TypeScriptComponentOutput } from '../../common-results.js';
+import { defaultTypeScriptGeneratorConfig, type TypeScriptGeneratorConfig } from '../../config.js';
+
+export type TypeScriptModelGeneratorConfig = TypeScriptGeneratorConfig & {
+  /**
+   * Determines how to generate enums.
+   * - 'union': Generate enums as union types.
+   * - 'prefer-enum': Generate enums as enums if possible, otherwise as union types.
+   * @default 'union'
+   */
+  enumGeneration: 'union' | 'prefer-enum';
+
+  /**
+   * Whether to generate immutable types.
+   * @default false
+   */
+  immutableTypes: boolean;
+
+  /**
+   * Whether to inline unnamed schemas. If false, unnamed schemas will be generated as separate types.
+   * @default true
+   */
+  inlineUnnamedSchemas: boolean;
+
+  /**
+   * The directory where the models should be saved. The path is relative to the output directory.
+   * @default 'models'
+   */
+  modelsDir: string;
+
+  /**
+   * The casing of the model file names. If nullish, the `fileNameCasing` is used.
+   * @default undefined
+   */
+  modelFileNameCasing: Nullable<ExtendedStringCasing>;
+
+  /**
+   * Determines how to declare types.
+   * - 'type': Always declare types as `type`.
+   * - 'prefer-interface': Prefer `interface` over `type` if possible.
+   * @default 'type'
+   */
+  typeDeclaration: 'type' | 'prefer-interface';
+};
+
+export type TypeScriptModelsGeneratorConfig = TypeScriptModelGeneratorConfig & {
+  /**
+   * The path to the index file where all models should be exported. If nullish, no index file will be generated.
+   * @default 'models.ts'
+   */
+  modelsIndexFile: Nullable<string>;
+};
+
+export const defaultTypeScriptModelGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptModelGeneratorConfig> = {
+  ...defaultTypeScriptGeneratorConfig,
+
+  enumGeneration: 'union',
+  immutableTypes: false,
+  inlineUnnamedSchemas: true,
+  modelsDir: 'models',
+  modelFileNameCasing: undefined,
+  typeDeclaration: 'type',
+};
+
+export const defaultTypeScriptModelsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptModelsGeneratorConfig> =
+  {
+    ...defaultTypeScriptModelGeneratorConfig,
+
+    modelsIndexFile: 'models.ts',
+  };
+
+// deno-lint-ignore ban-types
+export type TypeScriptModelsGeneratorInput = {};
+
+export type TypeScriptModelsGeneratorOutput = {
+  typescript: {
+    models: {
+      [schemaId: string]: TypeScriptModelGeneratorOutput;
+    };
+    indexFiles: {
+      models: Nullable<string>;
+    };
+  };
+};
+
+export type TypeScriptModelGeneratorOutput = TypeScriptComponentOutput;
+
+export type TypeScriptModelsGeneratorContext = OpenApiSchemasGenerationProviderContext<
+  TypeScriptModelsGeneratorInput,
+  TypeScriptModelsGeneratorOutput,
+  TypeScriptModelsGeneratorConfig,
+  TypeScriptModelGeneratorOutput
+>;
+
+export type TypeScriptModelGeneratorContext = TypeScriptModelsGeneratorContext & {
+  schema: ApiSchema;
+};

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

@@ -0,0 +1,402 @@
+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.angular.httpErrorResponse(),
+                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 ?? ts.refs.never(),
+        },
+      ]),
+      ...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, ts.refs.never()),
+          },
+        ]),
+    ]);
+  }
+  // #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(endpoint.requestBody.content[0].type ?? 'application/json')
+                      });`
+                      : 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 getEndpointSuccessResponseType(ctx: Context, endpoint: ApiEndpoint): string {
+    const response = this.getEndpointSuccessResponse(ctx, endpoint);
+    if (!response) return '*/*';
+
+    if (!ctx.config.defaultSuccessResponseType) return response.contentOptions[0]?.type ?? '*/*';
+
+    return (
+      response.contentOptions.find((x) => x.type === ctx.config.defaultSuccessResponseType)?.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';
+  }
+}