@goast/typescript 0.4.1 → 0.4.2

package/src/src/file-builder.ts

@@ -1,136 +0,0 @@
-import { dirname } from 'node:path';
-
-
-import fs from 'fs-extra';
-
-import { type AppendParam, type AppendValue, isAppendValue, type Nullable, SourceBuilder } from '@goast/core';
-
-import { TsNode } from './ast/node.js';
-import { defaultTypeScriptGeneratorConfig, type TypeScriptGeneratorConfig } from './config.js';
-import type { TypeScriptModelGeneratorOutput } from './generators/index.js';
-import {
-  ImportExportCollection,
-  type TypeScriptExportOptions,
-  type TypeScriptImportOptions,
-} from './import-collection.js';
-
-export type TypeScriptAppends<TAdditionalAppends> = TsNode<TypeScriptFileBuilder> | TAdditionalAppends;
-export type TypeScriptAppendParam<TBuilder extends TypeScriptFileBuilder, TAdditionalAppends> = AppendParam<
-  TBuilder,
-  TypeScriptAppends<TAdditionalAppends>
->;
-
-export function isTypeScriptAppendValue<TBuilder extends TypeScriptFileBuilder = TypeScriptFileBuilder>(
-  value: unknown,
-): value is AppendValue<TBuilder> {
-  return isAppendValue(value) || value instanceof TsNode;
-}
-
-export class TypeScriptFileBuilder<TAdditionalAppends = never>
-  extends SourceBuilder<TypeScriptAppends<TAdditionalAppends>> {
-  public readonly filePath: string | undefined;
-  public readonly imports: ImportExportCollection;
-
-  public override get options(): TypeScriptGeneratorConfig {
-    return super.options as TypeScriptGeneratorConfig;
-  }
-
-  constructor(filePath?: string, options?: TypeScriptGeneratorConfig) {
-    super(options ?? defaultTypeScriptGeneratorConfig);
-    this.filePath = filePath;
-    this.imports = new ImportExportCollection({
-      filePath: filePath,
-      importModuleTransformer: this.options.importModuleTransformer,
-      useSingleQuotes: this.options.useSingleQuotes,
-    });
-  }
-
-  public addImport(name: string, moduleNameOrfilePath: string, options?: TypeScriptImportOptions): this {
-    this.imports.addImport(name, moduleNameOrfilePath, options);
-    return this;
-  }
-
-  public addExport(name: string, filePath: string, options?: TypeScriptExportOptions): this {
-    this.imports.addExport(name, filePath, options);
-    return this;
-  }
-
-  public override clear(): void {
-    super.clear();
-    this.imports.clear();
-  }
-
-  public override toString(addPadding: boolean = true): string {
-    const builder = new SourceBuilder(this.options);
-    if (this.filePath?.match(/\.[cm]?js$/)) {
-      builder.appendLine('// @ts-check');
-    }
-
-    builder.ensurePreviousLineEmpty();
-    this.imports.writeTo(builder);
-
-    const baseString = super.toString();
-    if (baseString && addPadding) {
-      builder.ensurePreviousLineEmpty();
-    }
-
-    builder.append(baseString);
-
-    if (addPadding) {
-      builder.ensureCurrentLineEmpty();
-    }
-
-    return builder.toString();
-  }
-
-  protected override appendSingle(value: TypeScriptAppendParam<this, TAdditionalAppends>) {
-    super.appendSingle(value);
-    if (value instanceof TsNode) {
-      value.write(this);
-    }
-  }
-
-  public appendModelUsage(type: TypeScriptModelGeneratorOutput, options?: TypeScriptImportOptions): this {
-    this.append(type.component);
-    for (const i of type.imports) {
-      this.addImport(i.name, i.modulePath, { ...i, ...options });
-    }
-    return this;
-  }
-
-  public writeToFile(filePath?: string): void {
-    if (!filePath) filePath = this.filePath;
-    if (!filePath) throw new Error('File path is required');
-    fs.ensureDirSync(dirname(filePath));
-    fs.writeFileSync(filePath, this.toString());
-  }
-
-  public static generate(options: {
-    filePath: string;
-    logName?: Nullable<string>;
-    options?: TypeScriptGeneratorConfig;
-    generator: (builder: TypeScriptFileBuilder) => void;
-  }): void {
-    TypeScriptFileBuilder.tryGenerate(options);
-  }
-
-  public static tryGenerate({
-    filePath,
-    generator,
-    options,
-    logName,
-  }: {
-    filePath: Nullable<string>;
-    logName?: Nullable<string>;
-    options?: TypeScriptGeneratorConfig;
-    generator: (builder: TypeScriptFileBuilder) => void;
-  }) {
-    if (!filePath) return;
-    if (logName) {
-      console.log(`Generating ${logName} to ${filePath}...`);
-    }
-    const builder = new TypeScriptFileBuilder(filePath, options);
-    generator(builder);
-    builder.writeToFile();
-  }
-}

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

@@ -1,15 +0,0 @@
-import type { MaybePromise, OpenApiGenerationProviderContext, OpenApiGeneratorInput, SourceBuilder } from '@goast/core';
-
-import { ts } from '../ast/index.js';
-import type { TypeScriptGeneratorConfig } from '../config.js';
-
-export abstract class TypeScriptFileGenerator<
-  TContext extends OpenApiGenerationProviderContext<OpenApiGeneratorInput, TypeScriptGeneratorConfig>,
-  TOutput,
-> {
-  public abstract generate(context: TContext): MaybePromise<TOutput>;
-
-  protected getAnyType(context: TContext): ts.Reference<SourceBuilder> {
-    return context.config.preferUnknown ? ts.refs.unknown() : ts.refs.any();
-  }
-}

package/src/src/generators/index.ts

@@ -1,6 +0,0 @@
-export * from './file-generator.js';
-export * from './models/index.js';
-export * from './services/angular-services/index.js';
-export * from './services/easy-network-stub/index.js';
-export * from './services/fetch-clients/index.js';
-export * from './services/k6-clients/index.js';

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

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

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

@@ -1,469 +0,0 @@
-import { resolve } from 'node:path';
-
-import {
-  type ApiSchema,
-  type AppendValue,
-  type AppendValueGroup,
-  appendValueGroup,
-  type ArrayLikeApiSchema,
-  type CombinedLikeApiSchema,
-  getSchemaReference,
-  type MaybePromise,
-  notNullish,
-  type Nullable,
-  type ObjectLikeApiSchema,
-  resolveAnyOfAndAllOf,
-  type StringLikeApiSchema,
-  toCasing,
-} from '@goast/core';
-
-import { ts } from '../../ast/index.js';
-import type { TypeScriptComponentOutputKind } from '../../common-results.js';
-import { TypeScriptFileBuilder } from '../../file-builder.js';
-import { TypeScriptFileGenerator } from '../file-generator.js';
-import type { TypeScriptModelGeneratorContext, TypeScriptModelGeneratorOutput } from './models.js';
-
-type Context = TypeScriptModelGeneratorContext;
-type Output = TypeScriptModelGeneratorOutput;
-type Builder = TypeScriptFileBuilder;
-
-export interface TypeScriptModelGenerator<TOutput extends Output = Output> {
-  generate(ctx: Context): MaybePromise<TOutput>;
-}
-
-export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator<Context, Output>
-  implements TypeScriptModelGenerator {
-  public generate(ctx: Context): MaybePromise<Output> {
-    if (this.shouldGenerateTypeDeclaration(ctx, ctx.schema)) {
-      const name = this.getDeclarationTypeName(ctx, ctx.schema);
-      const filePath = this.getFilePath(ctx, ctx.schema);
-
-      const fileContent = this.getFileContent(ctx);
-      TypeScriptFileBuilder.generate({
-        logName: `model ${name}`,
-        filePath,
-        options: ctx.config,
-        generator: (b) => b.append(fileContent),
-      });
-
-      const exports = fileContent.values.filter(
-        (x): x is AppendValue<Builder> & { name: string; export: true } =>
-          typeof x === 'object' && x !== null && 'export' in x && x.export === true && 'name' in x,
-      );
-      const node = exports.find((x) => x.name === name);
-      return {
-        component: name,
-        filePath,
-        imports: [
-          {
-            kind: 'file',
-            name,
-            modulePath: filePath,
-            type: node instanceof ts.Interface || node instanceof ts.TypeAlias ? 'type-import' : 'import',
-          },
-        ],
-        additionalExports: exports
-          .filter((x) => x.name !== name)
-          .map(
-            (x) => ({
-              name: x.name,
-              type: x instanceof ts.TypeAlias || x instanceof ts.Interface ? 'type-export' : 'export',
-            } as const),
-          ),
-        kind: this.getNodeKind(node),
-      };
-    } else {
-      const builder = new TypeScriptFileBuilder(undefined, ctx.config);
-      builder.append(this.getType(ctx, ctx.schema));
-      const imports = builder.imports.imports;
-      builder.imports.clear();
-      return { component: builder.toString(false), imports };
-    }
-  }
-
-  protected getNodeKind(node: unknown): TypeScriptComponentOutputKind | undefined {
-    if (node instanceof ts.Interface) return 'interface';
-    if (node instanceof ts.TypeAlias) return 'type';
-    if (node instanceof ts.Enum) return 'enum';
-    if (node instanceof ts.Class) return 'class';
-    return undefined;
-  }
-
-  protected getFileContent(ctx: Context): AppendValueGroup<Builder> {
-    const content = appendValueGroup<Builder>([], '\n');
-    const interfaceSchema = this.resolveInterfaceSchema(ctx);
-    if (interfaceSchema) {
-      content.values.push(this.getInterface(ctx, interfaceSchema));
-    } else if (
-      ctx.config.enumGeneration !== 'union' &&
-      ctx.schema.kind === 'string' &&
-      ctx.schema.enum !== undefined &&
-      ctx.schema.enum.length > 0
-    ) {
-      content.values.push(this.getEnum(ctx));
-    } else if (ctx.schema.discriminator && Object.keys(ctx.schema.discriminator.mapping).length > 0) {
-      content.values.push(
-        ts.typeAlias(
-          this.getDiscriminatorTypeName(ctx, ctx.schema),
-          ts.unionType(Object.keys(ctx.schema.discriminator.mapping).map((x) => ts.string(x))),
-        ),
-        ts.typeAlias(
-          this.getBaseTypeName(ctx, ctx.schema),
-          this.getType(ctx, ctx.schema, { skipSchemas: true }) ?? this.getAnyType(ctx),
-          { export: true },
-        ),
-        this.getTypeAlias(ctx, ctx.schema),
-      );
-    } else {
-      content.values.push(this.getTypeAlias(ctx, ctx.schema));
-      if (ctx.schema.enum) {
-        content.values.push(this.getEnumValuesVariable(ctx, ctx.schema));
-      }
-    }
-    return content;
-  }
-
-  protected getEnum(ctx: Context): ts.Enum<Builder> {
-    return ts.enum(this.getDeclarationTypeName(ctx, ctx.schema), {
-      doc: ts.doc({
-        description: ctx.schema.description,
-        tags: [ctx.schema.deprecated ? ts.docTag('deprecated') : null],
-      }),
-      export: true,
-      members: (ctx.schema.enum?.map((x) => String(x)) ?? []).map((x) =>
-        ts.enumValue(toCasing(x, ctx.config.enumValueNameCasing), { value: ts.string(x) })
-      ),
-    });
-  }
-
-  protected getInterface(ctx: Context, schema: ObjectLikeApiSchema): ts.Interface<Builder> {
-    return ts.interface(this.getDeclarationTypeName(ctx, ctx.schema), {
-      export: true,
-      doc: ts.doc({
-        description: schema.description,
-        tags: [ctx.schema.deprecated ? ts.docTag('deprecated') : null],
-      }),
-      members: [...this.getProperties(ctx, schema), this.getIndexer(ctx, schema)],
-    });
-  }
-
-  protected getTypeAlias(ctx: Context, schema: ApiSchema): ts.TypeAlias<Builder> {
-    const hasDiscriminator = schema.discriminator && Object.keys(schema.discriminator.mapping).length > 0;
-    const result = ts.typeAlias<Builder>(
-      this.getDeclarationTypeName(ctx, schema),
-      (hasDiscriminator ? this.getDiscriminatorType(ctx, schema) : this.getType(ctx, schema, { skipSchemas: true })) ??
-        this.getAnyType(ctx),
-      {
-        export: true,
-        doc: ts.doc({
-          description: schema.description,
-          tags: [ctx.schema.deprecated ? ts.docTag('deprecated') : null],
-        }),
-      },
-    );
-
-    if (hasDiscriminator) {
-      const propertyValue = this.getDiscriminatorTypeName(ctx, ctx.schema);
-      result.generics.push(
-        ts.genericParameter(this.getDiscriminatorGenericParamName(ctx, schema), {
-          constraint: propertyValue,
-          default: propertyValue,
-        }),
-      );
-    }
-
-    const inheritedSchemas = this.getInheritedSchemas(ctx, schema);
-    if (inheritedSchemas.length > 0) {
-      const fixedProperties = inheritedSchemas.reduce((p, c) => {
-        const mappingValues = Object.entries(c.discriminator.mapping)
-          .filter(([_, value]) => value.id === schema.id)
-          .map(([key]) => ts.string(key));
-        if (c.discriminator.propertyName in p) {
-          p[c.discriminator.propertyName].types.push(...mappingValues);
-        } else {
-          p[c.discriminator.propertyName] = ts.unionType(mappingValues);
-        }
-        return p;
-      }, {} as Record<string, ts.UnionType<Builder>>);
-      result.type = ts.intersectionType([
-        ts.refs.omit([result.type, ts.unionType(Object.keys(fixedProperties).map((x) => ts.string(x)))]),
-        ts.objectType({
-          members: Object.entries(fixedProperties).map(([key, value]) =>
-            ts.property(key, { type: value, readonly: ctx.config.immutableTypes })
-          ),
-        }),
-      ]);
-    }
-
-    return result;
-  }
-
-  protected getEnumValuesVariable(ctx: Context, schema: ApiSchema): ts.Variable<Builder> {
-    const enumTypeName = this.getDeclarationTypeName(ctx, schema);
-    const values = schema.enum?.map((x) => ts.toNode(x)) ?? [];
-    return ts.variable(toCasing(`${enumTypeName}-Values`, ctx.config.constantNameCasing), {
-      doc: ts.doc({
-        description: `All possible values of the enum \`${enumTypeName}\`.`,
-      }),
-      export: true,
-      readonly: true,
-      value: ts.tuple(values, { asConst: true }),
-    });
-  }
-
-  protected getIndexer(ctx: Context, schema: ObjectLikeApiSchema): ts.Indexer<Builder> | null {
-    return schema.additionalProperties
-      ? ts.indexer(
-        ts.refs.string(),
-        (schema.additionalProperties === true ? null : this.getType(ctx, schema.additionalProperties)) ??
-          this.getAnyType(ctx),
-        { readonly: ctx.config.immutableTypes },
-      )
-      : null;
-  }
-
-  protected getProperties(ctx: Context, schema: ObjectLikeApiSchema): ts.Property<Builder>[] {
-    return Array.from(schema.properties.values()).map((property) => {
-      return ts.property(property.name, {
-        doc: ts.doc({
-          description: property.schema.description,
-          tags: [property.schema.deprecated ? ts.docTag('deprecated') : null],
-        }),
-        readonly: ctx.config.immutableTypes,
-        optional: !schema.required.has(property.name),
-        type: ts.unionType([this.getType(ctx, property.schema), property.schema.nullable ? 'null' : null]),
-      });
-    });
-  }
-
-  protected getType(
-    ctx: Context,
-    schema: Nullable<ApiSchema>,
-    options?: { skipSchemas?: boolean; useBaseType?: boolean },
-  ): ts.Type<Builder> | null {
-    if (!schema) return this.getAnyType(ctx);
-
-    schema = getSchemaReference(schema, ['description']);
-
-    if (options?.useBaseType && ctx.schema.inheritedSchemas.some((x) => x.id === schema.id)) {
-      return ts.reference(this.getBaseTypeName(ctx, schema), this.getFilePath(ctx, schema), {
-        importType: 'type-import',
-      });
-    }
-
-    if (!options?.skipSchemas && this.shouldGenerateTypeDeclaration(ctx, schema)) {
-      if (schema.id === ctx.schema.id) {
-        return null;
-      }
-      return ts.reference(this.getDeclarationTypeName(ctx, schema), this.getFilePath(ctx, schema), {
-        importType: 'type-import',
-      });
-    }
-
-    if (schema.enum) {
-      return ts.unionType(schema.enum.map((x) => ts.toNode(x)));
-    }
-
-    switch (schema.kind) {
-      case 'boolean':
-        return 'boolean';
-      case 'integer':
-      case 'number':
-        return 'number';
-      case 'string':
-        return this.getStringType(ctx, schema);
-      case 'null':
-        return 'null';
-      case 'unknown':
-        return this.getAnyType(ctx);
-      case 'array':
-        return this.getArrayType(ctx, schema);
-      case 'object':
-        return this.getObjectType(ctx, schema);
-      case 'combined':
-        return this.getCombinedType(ctx, schema);
-      case 'multi-type':
-        return this.getMultiType(ctx, schema);
-      case 'oneOf':
-        return this.getOneOfType(ctx, schema);
-      default:
-        return this.getAnyType(ctx);
-    }
-  }
-
-  protected getStringType(_ctx: Context, schema: StringLikeApiSchema): ts.Type<Builder> {
-    if (schema.format === 'binary') {
-      return ts.refs.blob();
-    }
-    return 'string';
-  }
-
-  protected getArrayType(ctx: Context, schema: ArrayLikeApiSchema): ts.Type<Builder> {
-    return ts.arrayType(this.getType(ctx, schema.items) ?? this.getAnyType(ctx), {
-      readonly: ctx.config.immutableTypes,
-    });
-  }
-
-  protected getObjectType(ctx: Context, schema: ObjectLikeApiSchema): ts.Type<Builder> {
-    const parts = [
-      schema.properties.size > 0 ? ts.objectType({ members: this.getProperties(ctx, schema) }) : null,
-      schema.additionalProperties ? ts.objectType({ members: [this.getIndexer(ctx, schema)] }) : null,
-      schema.allOf.length > 0 || schema.anyOf.length > 0 ? this.getCombinedType(ctx, schema) : null,
-    ].filter(notNullish);
-    if (parts.length === 0) {
-      parts.push(
-        ts.objectType({
-          members: [ts.indexer(ts.refs.string(), ts.refs.never(), { readonly: ctx.config.immutableTypes })],
-        }),
-      );
-    }
-    return ts.intersectionType(parts);
-  }
-
-  protected getDiscriminatorType(ctx: Context, schema: ApiSchema): ts.Type<Builder> {
-    if (schema.discriminator && Object.keys(schema.discriminator.mapping).length > 0) {
-      const discriminator = schema.discriminator;
-      return ts.intersectionType([
-        this.getBaseTypeName(ctx, schema as ApiSchema),
-        ts.lookupType(
-          ts.objectType({
-            members: Object.entries(discriminator.mapping).map(([key, value]) =>
-              ts.property(key, {
-                type: ts.intersectionType([
-                  ts.objectType({
-                    members: [
-                      ts.property(discriminator.propertyName, {
-                        type: ts.string(key),
-                        readonly: ctx.config.immutableTypes,
-                      }),
-                    ],
-                  }),
-                  this.getType(ctx, value),
-                ]),
-              })
-            ),
-          }),
-          this.getDiscriminatorGenericParamName(ctx, schema as ApiSchema),
-        ),
-      ]);
-    } else {
-      return ts.refs.unknown();
-    }
-  }
-
-  protected getCombinedType(ctx: Context, schema: CombinedLikeApiSchema): ts.Type<Builder> {
-    if (schema.allOf.length === 0 && schema.anyOf.length === 0) {
-      return this.getAnyType(ctx);
-    }
-    const useBaseType = schema.id === ctx.schema.id;
-    return ts.intersectionType([
-      ...schema.allOf.map((x) => this.getType(ctx, x, { useBaseType })),
-      ...schema.anyOf.map((x) => ts.reference('Partial', null, { generics: [this.getType(ctx, x, { useBaseType })] })),
-    ]);
-  }
-
-  protected getOneOfType(ctx: Context, schema: ApiSchema<'oneOf'>): ts.Type<Builder> {
-    if (schema.oneOf.length === 0) {
-      return this.getAnyType(ctx);
-    }
-    return ts.unionType(schema.oneOf.map((x) => this.getType(ctx, x)));
-  }
-
-  protected getMultiType(ctx: Context, schema: ApiSchema<'multi-type'>): ts.Type<Builder> {
-    if (schema.type.length === 0) {
-      return this.getAnyType(ctx);
-    }
-    return ts.unionType(
-      schema.type.map((x) => {
-        switch (x) {
-          case 'string':
-            return this.getStringType(ctx, schema);
-          case 'number':
-          case 'integer':
-            return 'number';
-          case 'boolean':
-            return 'boolean';
-          case 'null':
-            return 'null';
-          case 'array':
-            return this.getArrayType(ctx, schema);
-          case 'object':
-            return this.getObjectType(ctx, schema);
-          default:
-            return 'never';
-        }
-      }),
-    );
-  }
-
-  protected shouldGenerateTypeDeclaration(ctx: Context, schema: ApiSchema): boolean {
-    // All named schemas should have its own type declaration
-    if (!schema.isNameGenerated) {
-      return true;
-    }
-
-    // All enum types should have its own type declaration
-    if (schema.enum !== undefined && schema.enum.length > 0) {
-      return true;
-    }
-
-    // All primitive types already exist and do not need its own type declaration
-    if (
-      schema.kind !== 'array' &&
-      schema.kind !== 'combined' &&
-      schema.kind !== 'multi-type' &&
-      schema.kind !== 'object' &&
-      schema.kind !== 'oneOf'
-    ) {
-      return false;
-    }
-
-    // Dynamically generated schemas do not have its own type declaration
-    if (!ctx.data.schemas.some((x) => x.id === schema.id)) {
-      return false;
-    }
-
-    // For all other types, check if the user has enabled inline unnamed schemas
-    return !ctx.config.inlineUnnamedSchemas;
-  }
-
-  protected resolveInterfaceSchema(ctx: Context): ApiSchema<'object'> | undefined {
-    if (
-      ctx.config.typeDeclaration === 'prefer-interface' &&
-      (ctx.schema.kind === 'object' || ctx.schema.kind === 'combined')
-    ) {
-      return resolveAnyOfAndAllOf(ctx.schema, true);
-    }
-    return undefined;
-  }
-
-  protected getDeclarationTypeName(ctx: Context, schema: ApiSchema): string {
-    return toCasing(schema.name, ctx.config.typeNameCasing);
-  }
-
-  protected getDiscriminatorGenericParamName(ctx: Context, schema: ApiSchema): string {
-    return toCasing(schema.discriminator?.propertyName, ctx.config.genericParamNameCasing);
-  }
-
-  protected getDiscriminatorTypeName(ctx: Context, schema: ApiSchema): string {
-    return toCasing(schema.name + '_Discriminator', ctx.config.typeNameCasing);
-  }
-
-  protected getBaseTypeName(ctx: Context, schema: ApiSchema): string {
-    return toCasing(schema.name + '_Base', ctx.config.typeNameCasing);
-  }
-
-  protected getInheritedSchemas(ctx: Context, schema: ApiSchema): ApiSchema['inheritedSchemas'] {
-    return schema.inheritedSchemas
-      .filter((schema) => this.shouldGenerateTypeDeclaration(ctx, schema) && !schema.isNameGenerated)
-      .filter((item, index, self) => self.indexOf(item) === index);
-  }
-
-  protected getFilePath(ctx: Context, schema: ApiSchema): string {
-    return resolve(
-      ctx.config.outputDir,
-      ctx.config.modelsDir,
-      `${toCasing(schema.name, ctx.config.modelFileNameCasing ?? ctx.config.fileNameCasing)}.ts`,
-    );
-  }
-}