@goast/typescript 0.3.1 → 0.3.3

package/types/lib/generators/services/easy-network-stub/refs.d.ts

@@ -1,59 +1,77 @@
 import { TypeScriptEasyNetworkStubsGeneratorConfig } from './models';
 import { ts } from '../../../ast';
 export declare function getReferenceFactories(options: TypeScriptEasyNetworkStubsGeneratorConfig): {
-    easyNetworkStubWrapperOptions: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    easyNetworkStubWrapperOptions: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    stubRequestItem: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    stubRequestItem: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    stubRequestInfo: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+    stubRequestInfo: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
         infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
     } & {
         moduleNameOrfilePath: string;
     };
-    strictRouteResponseCallback: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>, ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+    strictRouteResponseCallback: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>, ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
         infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
     } & {
         moduleNameOrfilePath: string;
     };
-    getStubResponder: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+    getStubResponder: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
         infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
     } & {
         moduleNameOrfilePath: string;
     };
-    easyNetworkStubWrapper: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    easyNetworkStubWrapper: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    easyNetworkStubBase: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    easyNetworkStubBase: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    easyNetworkStubGroup: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+    easyNetworkStubGroup: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
         infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
     } & {
         moduleNameOrfilePath: string;
     };
-    createEasyNetworkStubGroup: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+    createEasyNetworkStubGroup: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>, ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
         infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;

package/types/lib/generators/services/fetch-clients/refs.d.ts

@@ -1,20 +1,26 @@
 import { TypeScriptFetchClientsGeneratorConfig } from './models';
 import { ts } from '../../../ast';
 export declare function getReferenceFactories(options: TypeScriptFetchClientsGeneratorConfig): {
-    typedResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+    typedResponse: (<TBuilder extends import("@goast/core").SourceBuilder>(generics: [ts.Type<TBuilder>], options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    } | undefined) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
         infer: <TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>;
     } & {
         moduleNameOrfilePath: string;
     };
-    fetchClientOptions: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    fetchClientOptions: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {
         moduleNameOrfilePath: string;
     };
-    urlBuilder: (<TBuilder extends import("@goast/core").SourceBuilder>() => ts.Reference<TBuilder, never>) & {
+    urlBuilder: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
         refName: string;
         moduleNameOrfilePath: import("@goast/core").Nullable<string>;
     } & {

package/types/lib/generators/services/k6-clients/index.d.ts

@@ -0,0 +1,3 @@
+export * from './k6-client-generator';
+export * from './k6-clients-generator';
+export * from './models';

package/types/lib/generators/services/k6-clients/k6-client-generator.d.ts

@@ -0,0 +1,39 @@
+import { ApiEndpoint, ApiSchema, AppendValueGroup } from '@goast/core';
+import { TypeScriptK6ClientGeneratorContext, TypeScriptK6ClientGeneratorOutput } from './models';
+import { ts } from '../../../ast';
+import { TypeScriptExportOutput } from '../../../common-results';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+import { TypeScriptImportOptions } from '../../../import-collection';
+import { TypeScriptFileGenerator } from '../../file-generator';
+type Context = TypeScriptK6ClientGeneratorContext;
+type Output = TypeScriptK6ClientGeneratorOutput;
+type Builder = TypeScriptFileBuilder;
+export interface TypeScriptK6ClientGenerator<TOutput extends Output = Output> {
+    generate(context: Context): TOutput;
+}
+export declare class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptK6ClientGenerator {
+    generate(ctx: TypeScriptK6ClientGeneratorContext): TypeScriptK6ClientGeneratorOutput;
+    protected generateResponseModels(ctx: Context): Record<string, TypeScriptExportOutput>;
+    protected getResponseModelFileContent(ctx: Context, endpoint: ApiEndpoint): AppendValueGroup<Builder>;
+    protected getEndpointStatusCodes(ctx: Context, endpoint: ApiEndpoint): Record<number, {
+        type: ts.Type<Builder>;
+    }>;
+    protected getClientFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getEndpointParamsType(ctx: Context, endpoint: ApiEndpoint): ts.Doc<Builder>;
+    protected getClass(ctx: Context): ts.Class<Builder>;
+    protected getEndpointMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder>;
+    protected getGetK6ParamsMethod(ctx: Context): ts.Method<Builder>;
+    protected getEndpointSuccessResponse(ctx: Context, endpoint: ApiEndpoint): import("@goast/core").ApiResponse | undefined;
+    protected getSchemaType(ctx: Context, schema: ApiSchema | undefined, options?: TypeScriptImportOptions & {
+        fallback?: ts.Type<Builder>;
+    }): ts.Type<Builder>;
+    protected getClassName(ctx: Context): string;
+    protected getResponseModelName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointParamsTypeName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointPathPropertyName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getEndpointMethodName(ctx: Context, endpoint: ApiEndpoint): string;
+    protected getFilePath(ctx: Context): string;
+    protected getResponseModelFilePath(ctx: Context): string;
+    protected hasEndpointParams(ctx: Context, endpoint: ApiEndpoint): boolean;
+}
+export {};

package/types/lib/generators/services/k6-clients/k6-clients-generator.d.ts

@@ -0,0 +1,27 @@
+import { OpenApiServicesGenerationProviderBase, Factory, OpenApiGeneratorContext, ApiService, AppendValueGroup } from '@goast/core';
+import { TypeScriptK6ClientGenerator } from './k6-client-generator';
+import { TypeScriptK6ClientsGeneratorInput, TypeScriptK6ClientsGeneratorOutput, TypeScriptK6ClientsGeneratorConfig, TypeScriptK6ClientGeneratorOutput, TypeScriptK6ClientsGeneratorContext } from './models';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+type Input = TypeScriptK6ClientsGeneratorInput;
+type Output = TypeScriptK6ClientsGeneratorOutput;
+type Config = TypeScriptK6ClientsGeneratorConfig;
+type ServiceOutput = TypeScriptK6ClientGeneratorOutput;
+type Context = TypeScriptK6ClientsGeneratorContext;
+export declare class TypeScriptK6ClientsGenerator extends OpenApiServicesGenerationProviderBase<Input, Output, Config, ServiceOutput, Context> {
+    private readonly _clientGeneratorFactory;
+    constructor(clientGeneratorFactory?: Factory<TypeScriptK6ClientGenerator, []>);
+    protected initResult(): Output;
+    protected buildContext(context: OpenApiGeneratorContext<Input>, config?: Partial<Config> | undefined): Context;
+    onGenerate(ctx: Context): Output;
+    protected generateService(ctx: Context, service: ApiService): ServiceOutput;
+    protected addServiceResult(ctx: Context, service: ApiService, result: ServiceOutput): void;
+    protected generateUtilsFiles(ctx: Context): void;
+    protected getHttpStatusCodeFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected generateIndexFiles(ctx: Context): Output['typescript']['indexFiles'];
+    protected getIndexFilePath(ctx: Context): string | null;
+    protected getResponseModelsIndexFilePath(ctx: Context): string | null;
+    protected getIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    protected getResponseModelsIndexFileContent(ctx: Context): AppendValueGroup<TypeScriptFileBuilder>;
+    private copyFile;
+}
+export {};

package/types/lib/generators/services/k6-clients/models.d.ts

@@ -0,0 +1,118 @@
+import { Nullable, ExtendedStringCasing, DefaultGenerationProviderConfig, ApiService, OpenApiServicesGenerationProviderContext, ApiSchema } from '@goast/core';
+import { getReferenceFactories } from './refs';
+import { ts } from '../../../ast';
+import { TypeScriptExportOutput } from '../../../common-results';
+import { TypeScriptGeneratorConfig } from '../../../config';
+import { TypeScriptFileBuilder } from '../../../file-builder';
+import { TypeScriptModelsGeneratorOutput } from '../../models';
+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';
+        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 declare const defaultTypeScriptK6ClientsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptK6ClientsGeneratorConfig>;
+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/types/lib/generators/services/k6-clients/refs.d.ts

@@ -0,0 +1,20 @@
+import { TypeScriptK6ClientsGeneratorConfig } from './models';
+import { ts } from '../../../ast';
+export declare function getReferenceFactories(options: TypeScriptK6ClientsGeneratorConfig): {
+    requestBuilder: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    httpStatusCode: (<TBuilder extends import("@goast/core").SourceBuilder>(options?: {
+        importType?: import("@goast/core").Nullable<import("../../../common-results").TypeScriptImportType>;
+    }) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+};

package/types/lib/import-collection.d.ts

@@ -1,5 +1,5 @@
 import { SourceBuilderOptions, StringBuilder } from '@goast/core';
-import { TypeScriptImport, TypeScriptImportKind } from './common-results';
+import { TypeScriptImport, TypeScriptImportKind, TypeScriptImportType } from './common-results';
 import { ImportModuleTransformer } from './utils';
 export type ImportExportCollectionOptions = {
     filePath?: string;
@@ -7,20 +7,27 @@ export type ImportExportCollectionOptions = {
     useSingleQuotes: boolean;
 };
 export declare const defaultImportExportCollectionOptions: ImportExportCollectionOptions;
+export type TypeScriptImportOptions = {
+    type?: TypeScriptImportType;
+};
 export declare class ImportExportCollection {
     private readonly _imports;
+    private readonly _typeImports;
+    private readonly _jsDocImports;
     private readonly _exports;
     private readonly _options;
     constructor(options?: Partial<ImportExportCollectionOptions>);
     get hasImports(): boolean;
     get hasExports(): boolean;
     get imports(): TypeScriptImport[];
-    addImport(importName: string, fromModule: string): void;
+    private toImport;
+    addImport(importName: string, fromModule: string, options?: TypeScriptImportOptions): void;
+    getImportMap(type: TypeScriptImportType): Map<string, Set<string>>;
     addExport(exportName: string, fromModule: string): void;
     clear(): void;
     toString(options: Partial<SourceBuilderOptions>): string;
     writeTo(builder: StringBuilder): void;
-    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export', data: (readonly [string, TypeScriptImportKind, string[]])[], options: {
+    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export' | 'import type' | ' * @import', data: (readonly [string, TypeScriptImportKind, string[]])[], options: {
         useSingleQuotes: boolean;
     }): void;
     protected sortAndResolve(data: Map<string, Set<string>>, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): (readonly [string, TypeScriptImportKind, string[]])[];