@goast/typescript 0.4.0 → 0.4.1-beta1

package/src/src/generators/services/k6-clients/models.ts

@@ -1,241 +0,0 @@
-import type {
-  ApiSchema,
-  ApiService,
-  DefaultGenerationProviderConfig,
-  ExtendedStringCasing,
-  Nullable,
-  OpenApiServicesGenerationProviderContext,
-} from '@goast/core';
-
-import type { ts } from '../../../ast/index.js';
-import type { TypeScriptExportOutput } from '../../../common-results.js';
-import { defaultTypeScriptGeneratorConfig, type TypeScriptGeneratorConfig } from '../../../config.js';
-import type { TypeScriptFileBuilder } from '../../../file-builder.js';
-import type { TypeScriptModelsGeneratorOutput } from '../../models/index.js';
-import type { getReferenceFactories } from './refs.js';
-
-export type TypeScriptK6ClientsGeneratorConfig = TypeScriptGeneratorConfig & {
-  /**
-   * Whether to use strict response types for the services.
-   * If enabled only the status codes are included that are defined in the OpenAPI specification or the `defaultStatusCodeResponseTypes` option.
-   * @default true
-   */
-  strictResponseTypes: boolean;
-
-  /**
-   * The default response types for status codes that are not defined in the OpenAPI specification.
-   * @example
-   * {
-   *   400: {
-   *     parser: 'json',
-   *     type: schemas =>
-   *       schemas.find(s => s.name === 'BadRequestResponse')
-   *         ?? throwExp('BadRequestResponse not found'),
-   *   },
-   *   404: null,
-   *   500: {
-   *     parser: 'json',
-   *     type: ts.refs.any(),
-   *   },
-   * }
-   * @default
-   * {
-   *   401: null,
-   *   403: null,
-   *   500: null,
-   * }
-   */
-  defaultStatusCodeResponseTypes: Record<
-    number,
-    {
-      parser: 'text' | 'json';
-      // deno-lint-ignore ban-types
-      type: Exclude<ts.Type<TypeScriptFileBuilder>, Function> | ((schemas: readonly ApiSchema[]) => ApiSchema);
-    } | null
-  >;
-
-  /**
-   * The possible status codes that any API endpoint can return.
-   * This is only used when `strictResponseTypes` is set to `false`.
-   * @default
-   * [100, 101, 102, 103, 200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 300, 301, 302, 303, 304, 305, 306, 307, 308, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451, 500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511]
-   */
-  possibleStatusCodes: number[];
-
-  /**
-   * The casing of the client file names. If nullish, the `fileNameCasing` is used.
-   * @default { casing: 'kebab', suffix: '-client' }
-   */
-  clientFileNameCasing: Nullable<ExtendedStringCasing>;
-
-  /**
-   * The casing of the file names for the response models. If nullish, the `fileNameCasing` is used.
-   * @default { casing: 'kebab', suffix: '-responses' }
-   */
-  responseModelFileNameCasing: Nullable<ExtendedStringCasing>;
-
-  /**
-   * The casing of the client names. If nullish, the `typeNameCasing` is used.
-   * @default { casing: 'pascal', suffix: 'Client' }
-   */
-  clientNameCasing: Nullable<ExtendedStringCasing>;
-
-  /**
-   * The directory where the client files should be saved. The path is relative to the output directory.
-   * @default 'clients'
-   */
-  clientDir: string;
-
-  /**
-   * The directory where the response models should be saved. The path is relative to the output directory.
-   * @default 'models/responses'
-   */
-  responseModelsDir: string;
-
-  /**
-   * The index file where all clients should be exported. The path is relative to the output directory. If nullish, no index file will be generated.
-   * @default 'clients.ts'
-   */
-  clientsIndexFile: Nullable<string>;
-
-  /**
-   * The path to the index file where all response models should be exported. The path is relative to the output directory. If nullish, no index file will be generated.
-   * @default 'responses.ts'
-   */
-  responseModelsIndexFile: Nullable<string>;
-
-  /**
-   * The directory where the utilies should be saved. The path is relative to the output directory.
-   * @default 'utils'
-   */
-  utilsDir: string;
-
-  /**
-   * Whether to generate clients calling the async API of k6.
-   * @default true
-   */
-  async: boolean;
-};
-
-export const defaultTypeScriptK6ClientsGeneratorConfig: DefaultGenerationProviderConfig<
-  TypeScriptK6ClientsGeneratorConfig
-> = {
-  ...defaultTypeScriptGeneratorConfig,
-  importModuleTransformer: 'js-extension',
-
-  strictResponseTypes: true,
-  defaultStatusCodeResponseTypes: {
-    401: null,
-    403: null,
-    500: null,
-  },
-  possibleStatusCodes: [
-    100,
-    101,
-    102,
-    103,
-    200,
-    201,
-    202,
-    203,
-    204,
-    205,
-    206,
-    207,
-    208,
-    226,
-    300,
-    301,
-    302,
-    303,
-    304,
-    305,
-    306,
-    307,
-    308,
-    400,
-    401,
-    402,
-    403,
-    404,
-    405,
-    406,
-    407,
-    408,
-    409,
-    410,
-    411,
-    412,
-    413,
-    414,
-    415,
-    416,
-    417,
-    421,
-    422,
-    423,
-    424,
-    425,
-    426,
-    428,
-    429,
-    431,
-    451,
-    500,
-    501,
-    502,
-    503,
-    504,
-    505,
-    506,
-    507,
-    508,
-    510,
-    511,
-  ],
-
-  clientFileNameCasing: { casing: 'kebab', suffix: '-client' },
-  responseModelFileNameCasing: { casing: 'kebab', suffix: '-responses' },
-  clientNameCasing: { casing: 'pascal', suffix: 'Client' },
-  clientDir: 'clients',
-  responseModelsDir: 'models/responses',
-  clientsIndexFile: 'clients.js',
-  responseModelsIndexFile: 'responses.ts',
-  utilsDir: 'utils',
-  async: true,
-};
-
-export type TypeScriptK6ClientsGeneratorInput = TypeScriptModelsGeneratorOutput;
-
-export type TypeScriptK6ClientsGeneratorOutput = {
-  typescript: {
-    k6Clients: {
-      [serviceId: string]: TypeScriptK6ClientGeneratorOutput;
-    };
-    indexFiles: {
-      k6Clients: Nullable<string>;
-      k6ResponseModels: Nullable<string>;
-    };
-  };
-};
-
-export type TypeScriptK6ClientGeneratorOutput = TypeScriptExportOutput & {
-  responseModels: {
-    [operationId: string]: TypeScriptExportOutput;
-  };
-};
-
-export type TypeScriptK6ClientsGeneratorContext =
-  & OpenApiServicesGenerationProviderContext<
-    TypeScriptK6ClientsGeneratorInput,
-    TypeScriptK6ClientsGeneratorOutput,
-    TypeScriptK6ClientsGeneratorConfig,
-    TypeScriptK6ClientGeneratorOutput
-  >
-  & {
-    refs: ReturnType<typeof getReferenceFactories>;
-  };
-
-export type TypeScriptK6ClientGeneratorContext = TypeScriptK6ClientsGeneratorContext & {
-  readonly service: ApiService;
-};

package/src/src/generators/services/k6-clients/refs.ts

@@ -1,15 +0,0 @@
-import { join, resolve } from 'node:path';
-
-import { ts } from '../../../ast/index.js';
-import type { TypeScriptK6ClientsGeneratorConfig } from './models.js';
-
-export function getReferenceFactories(options: TypeScriptK6ClientsGeneratorConfig): {
-  requestBuilder: ts.ModuleReferenceFactory;
-  httpStatusCode: ts.ModuleReferenceFactory;
-} {
-  const utilsDirPath = resolve(options.outputDir, options.utilsDir);
-  return {
-    requestBuilder: ts.reference.factory('RequestBuilder', join(utilsDirPath, 'request-builder.js')),
-    httpStatusCode: ts.reference.factory('HttpStatusCode', join(utilsDirPath, 'http-status-code.ts')),
-  };
-}

package/src/src/import-collection.test.ts

@@ -1,78 +0,0 @@
-import "../_dnt.test_polyfills.js";
-import type { SourceBuilderOptions } from '@goast/core';
-
-import { expect } from '../deps/jsr.io/@std/expect/1.0.5/mod.js';
-import { beforeEach, describe, it } from '../deps/jsr.io/@std/testing/1.0.3/bdd.js';
-
-import { ImportExportCollection } from './import-collection.js';
-
-describe('ImportExportCollection', () => {
-  let collection: ImportExportCollection;
-  let sourceBuilderOptions: Partial<SourceBuilderOptions>;
-
-  beforeEach(() => {
-    collection = new ImportExportCollection({ importModuleTransformer: 'omit-extension' });
-    sourceBuilderOptions = { newLine: '\n' };
-  });
-
-  describe('addImport', () => {
-    it('should add a new import to the collection', () => {
-      collection.addImport('myImport', 'myModule');
-      expect(collection.hasImports).toBe(true);
-      expect(collection.hasExports).toBe(false);
-      expect(collection.toString(sourceBuilderOptions)).toBe("import { myImport } from 'myModule';\n");
-    });
-
-    it('should add a new import to an existing module', () => {
-      collection.addImport('myImport1', 'myModule');
-      collection.addImport('myImport2', 'myModule');
-      expect(collection.hasImports).toBe(true);
-      expect(collection.hasExports).toBe(false);
-      expect(collection.toString(sourceBuilderOptions)).toBe("import { myImport1, myImport2 } from 'myModule';\n");
-    });
-  });
-
-  describe('addExport', () => {
-    it('should add a new export to the collection', () => {
-      collection.addExport('myExport', 'myModule');
-      expect(collection.hasImports).toBe(false);
-      expect(collection.hasExports).toBe(true);
-      expect(collection.toString(sourceBuilderOptions)).toBe("export { myExport } from 'myModule';\n");
-    });
-
-    it('should add a new export to an existing module', () => {
-      collection.addExport('myExport1', 'myModule');
-      collection.addExport('myExport2', 'myModule');
-      expect(collection.hasImports).toBe(false);
-      expect(collection.hasExports).toBe(true);
-      expect(collection.toString(sourceBuilderOptions)).toBe("export { myExport1, myExport2 } from 'myModule';\n");
-    });
-  });
-
-  describe('clear', () => {
-    it('should clear the collection', () => {
-      collection.addImport('myImport', 'myModule');
-      collection.addExport('myExport', 'myModule');
-      expect(collection.hasImports).toBe(true);
-      expect(collection.hasExports).toBe(true);
-      collection.clear();
-      expect(collection.hasImports).toBe(false);
-      expect(collection.hasExports).toBe(false);
-      expect(collection.toString(sourceBuilderOptions)).toBe('');
-    });
-  });
-
-  describe('toString', () => {
-    it('should return an empty string if the collection is empty', () => {
-      expect(collection.toString(sourceBuilderOptions)).toBe('');
-    });
-
-    it('should return a string representation of the collection', () => {
-      collection.addImport('myImport', 'myModule');
-      collection.addExport('myExport', 'myModule');
-      expect(collection.toString(sourceBuilderOptions)).toBe(
-        "import { myImport } from 'myModule';\n\nexport { myExport } from 'myModule';\n",
-      );
-    });
-  });
-});

package/src/src/import-collection.ts

@@ -1,236 +0,0 @@
-import { extname } from 'node:path';
-
-import { type SourceBuilderOptions, StringBuilder } from '@goast/core';
-
-import type {
-  TypeScriptExportType,
-  TypeScriptImport,
-  TypeScriptImportKind,
-  TypeScriptImportType,
-} from './common-results.js';
-import { defaultTypeScriptGeneratorConfig } from './config.js';
-import { getModulePathRelativeToFile, type ImportModuleTransformer } from './utils.js';
-
-export type ImportExportCollectionOptions = {
-  filePath?: string;
-  importModuleTransformer: ImportModuleTransformer;
-  useSingleQuotes: boolean;
-};
-
-export const defaultImportExportCollectionOptions: ImportExportCollectionOptions = {
-  importModuleTransformer: defaultTypeScriptGeneratorConfig.importModuleTransformer,
-  useSingleQuotes: defaultTypeScriptGeneratorConfig.useSingleQuotes,
-};
-
-export type TypeScriptImportOptions = { type?: TypeScriptImportType };
-export type TypeScriptExportOptions = { type?: TypeScriptExportType };
-
-export class ImportExportCollection {
-  private readonly _imports: Map<string, Set<string>> = new Map();
-  private readonly _typeImports: Map<string, Set<string>> = new Map();
-  private readonly _jsDocImports: Map<string, Set<string>> = new Map();
-  private readonly _exports: Map<string, Set<string>> = new Map();
-  private readonly _typeExports: Map<string, Set<string>> = new Map();
-  private readonly _options: ImportExportCollectionOptions;
-
-  constructor(options?: Partial<ImportExportCollectionOptions>) {
-    this._options = { ...defaultImportExportCollectionOptions, ...options };
-  }
-
-  public get hasImports(): boolean {
-    return this._imports.size > 0 || this._typeImports.size > 0 || this._jsDocImports.size > 0;
-  }
-
-  public get hasExports(): boolean {
-    return this._exports.size > 0 || this._typeExports.size > 0;
-  }
-
-  public get imports(): TypeScriptImport[] {
-    return [
-      ...this.toImport('import', this._imports),
-      ...this.toImport('type-import', this._typeImports),
-      ...this.toImport('js-doc', this._jsDocImports),
-    ];
-  }
-
-  private toImport(type: TypeScriptImportType, map: Map<string, Set<string>>): TypeScriptImport[] {
-    return Array.from(map.entries())
-      .map(([fromModule, importNames]) =>
-        Array.from(importNames).map(
-          (importName) => ({
-            kind: this.getImportKind(fromModule),
-            type,
-            modulePath: fromModule,
-            name: importName,
-          } satisfies TypeScriptImport),
-        )
-      )
-      .flat();
-  }
-
-  public addImport(importName: string, fromModule: string, options?: TypeScriptImportOptions): void {
-    const map = this.getImportMap(options?.type ?? 'import');
-    const existingImport = map.get(fromModule);
-    if (existingImport) {
-      existingImport.add(importName);
-    } else {
-      map.set(fromModule, new Set([importName]));
-    }
-  }
-
-  public addExport(exportName: string, fromModule: string, options?: TypeScriptExportOptions): void {
-    const map = this.getExportMap(options?.type ?? 'export');
-    const existingExport = map.get(fromModule);
-    if (existingExport) {
-      existingExport.add(exportName);
-    } else {
-      map.set(fromModule, new Set([exportName]));
-    }
-  }
-
-  public clear(): void {
-    this._imports.clear();
-    this._typeImports.clear();
-    this._jsDocImports.clear();
-    this._exports.clear();
-    this._typeExports.clear();
-  }
-
-  public toString(options: Partial<SourceBuilderOptions>): string {
-    const builder = new StringBuilder(options);
-    this.writeTo(builder);
-    return builder.toString();
-  }
-
-  public writeTo(builder: StringBuilder) {
-    const { filePath, importModuleTransformer, useSingleQuotes } = this._options;
-    let hasPrevious = false;
-
-    if (this._imports.size > 0) {
-      const sortedImports = this.sortAndResolve(this._imports, filePath, importModuleTransformer);
-      this.writeImportsExports(builder, 'import', sortedImports, { useSingleQuotes });
-      hasPrevious = true;
-    }
-
-    if (this._typeImports.size > 0) {
-      if (hasPrevious) {
-        builder.appendLine();
-      }
-      const sortedImports = this.sortAndResolve(this._typeImports, filePath, importModuleTransformer);
-      this.writeImportsExports(builder, 'import type', sortedImports, { useSingleQuotes });
-      hasPrevious = true;
-    }
-
-    if (this._jsDocImports.size > 0) {
-      if (hasPrevious) {
-        builder.appendLine();
-      }
-      const sortedImports = this.sortAndResolve(this._jsDocImports, filePath, importModuleTransformer);
-      builder.appendLine('/**');
-      this.writeImportsExports(builder, ' * @import', sortedImports, { useSingleQuotes });
-      builder.appendLine(' */');
-      hasPrevious = true;
-    }
-
-    if (this._exports.size > 0) {
-      if (hasPrevious) {
-        builder.appendLine();
-      }
-      const sortedExports = this.sortAndResolve(this._exports, filePath, importModuleTransformer);
-      this.writeImportsExports(builder, 'export', sortedExports, { useSingleQuotes });
-      hasPrevious = true;
-    }
-
-    if (this._typeExports.size > 0) {
-      if (hasPrevious) {
-        builder.appendLine();
-      }
-      const sortedExports = this.sortAndResolve(this._typeExports, filePath, importModuleTransformer);
-      this.writeImportsExports(builder, 'export type', sortedExports, { useSingleQuotes });
-      hasPrevious = true;
-    }
-  }
-
-  protected writeImportsExports(
-    builder: StringBuilder,
-    keyword: 'import' | 'export' | 'import type' | 'export type' | ' * @import',
-    data: (readonly [string, TypeScriptImportKind, string[]])[],
-    options: { useSingleQuotes: boolean },
-  ) {
-    const moduleData: (readonly [string, TypeScriptImportKind, string[]])[] = [];
-    const fileData: (readonly [string, TypeScriptImportKind, string[]])[] = [];
-    for (const x of data) {
-      if (x[1] === 'module') {
-        moduleData.push(x);
-      } else {
-        fileData.push(x);
-      }
-    }
-
-    const quote = options.useSingleQuotes ? "'" : '"';
-
-    for (const [fromModule, _, names] of moduleData) {
-      builder.appendLine(`${keyword} { ${names.join(', ')} } from ${quote}${fromModule}${quote};`);
-    }
-
-    if (moduleData.length > 0 && fileData.length > 0) {
-      builder.appendLine();
-    }
-
-    for (const [fromModule, _, names] of fileData) {
-      builder.appendLine(`${keyword} { ${names.join(', ')} } from ${quote}${fromModule}${quote};`);
-    }
-  }
-
-  protected sortAndResolve(
-    data: Map<string, Set<string>>,
-    filePath: string | undefined,
-    importModuleTransformer: ImportModuleTransformer,
-  ): (readonly [string, TypeScriptImportKind, string[]])[] {
-    return Array.from(data.entries())
-      .sort(([fromModuleA], [fromModuleB]) => fromModuleA.localeCompare(fromModuleB))
-      .map(
-        ([fromModule, names]) =>
-          [...this.resolveModulePath(fromModule, filePath, importModuleTransformer), Array.from(names).sort()] as const,
-      );
-  }
-
-  protected getImportKind(fromModule: string): TypeScriptImportKind {
-    const extName = extname(fromModule).toUpperCase();
-    return extName === '.TS' || extName === '.JS' || extName === '.JSON' ? 'file' : 'module';
-  }
-
-  protected resolveModulePath(
-    fromModule: string,
-    filePath: string | undefined,
-    importModuleTransformer: ImportModuleTransformer,
-  ): [string, TypeScriptImportKind] {
-    const kind = this.getImportKind(fromModule);
-    return [
-      filePath && kind === 'file'
-        ? getModulePathRelativeToFile(filePath, fromModule, importModuleTransformer)
-        : fromModule,
-      kind,
-    ];
-  }
-
-  protected getImportMap(type: TypeScriptImportType): Map<string, Set<string>> {
-    switch (type) {
-      case 'import':
-        return this._imports;
-      case 'type-import':
-        return this._typeImports;
-      case 'js-doc':
-        return this._jsDocImports;
-    }
-  }
-
-  protected getExportMap(type: TypeScriptExportType): Map<string, Set<string>> {
-    switch (type) {
-      case 'export':
-        return this._exports;
-      case 'type-export':
-        return this._typeExports;
-    }
-  }
-}

package/src/src/utils.ts

@@ -1,72 +0,0 @@
-import { dirname, relative } from 'node:path';
-
-import type { Nullable } from '@goast/core';
-
-export type ImportModuleTransformer =
-  | 'omit-extension'
-  | 'with-extension'
-  | 'js-extension'
-  | ((module: string) => string);
-
-function doubleQuotedToSingleQuoted(value: string): string {
-  return `'${value.slice(1, -1).replace(/'/g, "\\'")}'`;
-}
-
-export function toTypeScriptStringLiteral(value: string, useSingleQuotes: boolean): string {
-  return useSingleQuotes ? doubleQuotedToSingleQuoted(JSON.stringify(value)) : JSON.stringify(value);
-}
-
-export function toTypeScriptPropertyName(value: string, useSingleQuotes: boolean): string {
-  if (value.match(/^[a-zA-Z_$][a-zA-Z_$0-9]*$/)) {
-    return value;
-  }
-  return useSingleQuotes ? doubleQuotedToSingleQuoted(JSON.stringify(value)) : JSON.stringify(value);
-}
-
-export function getModulePathRelativeToFile(from: string, to: string, transformer: ImportModuleTransformer): string {
-  return transformModulePath(relative(dirname(from), to).replace(/\\/g, '/'), transformer);
-}
-
-export function getModulePathRelativeToDirectory(
-  from: string,
-  to: string,
-  transformer: ImportModuleTransformer,
-): string {
-  return transformModulePath(relative(from, to).replace(/\\/g, '/'), transformer);
-}
-
-function transformModulePath(modulePath: string, transformer: ImportModuleTransformer) {
-  if (!modulePath.startsWith('.')) {
-    modulePath = `./${modulePath}`;
-  }
-
-  if (transformer === 'omit-extension') {
-    return modulePath.replace(/\.[^/.]+$/, '');
-  } else if (transformer === 'with-extension') {
-    return modulePath;
-  } else if (transformer === 'js-extension') {
-    return modulePath.replace(/\.[^/.]+$/, '.js');
-  } else if (typeof transformer === 'function') {
-    return transformer(modulePath);
-  }
-
-  return modulePath;
-}
-
-export function modifyString<TArgs extends unknown[]>(
-  value: string,
-  modifier: Nullable<string | RegExp | ((value: string, ...args: TArgs) => string)>,
-  ...args: TArgs
-): string {
-  if (typeof modifier === 'string') {
-    return modifier;
-  }
-  if (modifier instanceof RegExp) {
-    const match = value.match(modifier);
-    return match?.[0] ?? value;
-  }
-  if (typeof modifier === 'function') {
-    return modifier(value, ...args);
-  }
-  return value;
-}