@goast/typescript 0.0.5 → 0.2.0

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

@@ -0,0 +1,51 @@
+import { ApiSchema, ApiService, DefaultGenerationProviderConfig, Nullable, OpenApiServicesGenerationProviderContext } 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 { TypeScriptModelGeneratorOutput } from '../../models';
+export type TypeScriptEasyNetworkStubsGeneratorConfig = TypeScriptGeneratorConfig & {
+    /**
+     * The default response types for status codes that are not defined in the OpenAPI specification.
+     * @example
+     * {
+     *   400: schemas =>
+     *     schemas.find(s => s.name === 'BadRequestResponse')
+     *       ?? throwExp('BadRequestResponse not found'),
+     *   404: 'never',
+     *   500: ts.refs.any(),
+     * }
+     * @default
+     * {
+     *   401: ts.refs.never(),
+     *   403: ts.refs.never(),
+     *   500: ts.refs.never(),
+     * }
+     */
+    defaultStatusCodeResponseTypes: Record<number, Exclude<ts.Type<TypeScriptFileBuilder>, Function> | ((schemas: readonly ApiSchema[]) => ApiSchema)>;
+    stubsDirPath: string;
+    stubsIndexFilePath: Nullable<string>;
+    utilsDirPath: string;
+};
+export declare const defaultTypeScriptEasyNetworkStubsGeneratorConfig: DefaultGenerationProviderConfig<TypeScriptEasyNetworkStubsGeneratorConfig>;
+export type TypeScriptEasyNetworkStubsGeneratorInput = {
+    models: {
+        [schemaId: string]: TypeScriptModelGeneratorOutput;
+    };
+};
+export type TypeScriptEasyNetworkStubsGeneratorOutput = {
+    stubs: {
+        [serviceId: string]: TypeScriptEasyNetworkStubGeneratorOutput;
+    };
+    indexFiles: {
+        stubs: Nullable<string>;
+    };
+};
+export type TypeScriptEasyNetworkStubGeneratorOutput = TypeScriptExportOutput;
+export type TypeScriptEasyNetworkStubsGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptEasyNetworkStubsGeneratorInput, TypeScriptEasyNetworkStubsGeneratorOutput, TypeScriptEasyNetworkStubsGeneratorConfig, TypeScriptEasyNetworkStubGeneratorOutput> & {
+    refs: ReturnType<typeof getReferenceFactories>;
+};
+export type TypeScriptEasyNetworkStubGeneratorContext = TypeScriptEasyNetworkStubsGeneratorContext & {
+    readonly service: ApiService;
+};

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

@@ -0,0 +1,49 @@
+import { TypeScriptEasyNetworkStubsGeneratorConfig } from './models';
+import { ts } from '../../../ast';
+export declare function getReferenceFactories(options: TypeScriptEasyNetworkStubsGeneratorConfig): {
+    easyNetworkStubWrapperOptions: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    stubRequestItem: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    stubRequestInfo: (<TBuilder_1 extends import("@goast/core").SourceBuilder<never>>(generics: [ts.Type<TBuilder_1>, ts.Type<TBuilder_1>]) => ts.Reference<TBuilder_1, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder_2 extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder_2, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    strictRouteResponseCallback: (<TBuilder_3 extends import("@goast/core").SourceBuilder<never>>(generics: [ts.Type<TBuilder_3>, ts.Type<TBuilder_3>, ts.Type<TBuilder_3>]) => ts.Reference<TBuilder_3, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder_4 extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder_4, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    getStubResponder: (<TBuilder_5 extends import("@goast/core").SourceBuilder<never>>(generics: [ts.Type<TBuilder_5>]) => ts.Reference<TBuilder_5, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder_6 extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder_6, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    easyNetworkStubWrapper: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    easyNetworkStubBase: (<TBuilder extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+};

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

@@ -1,5 +1,6 @@
-import { ApiEndpoint, ApiSchema } from '@goast/core';
+import { ApiEndpoint, ApiSchema, AppendValueGroup } from '@goast/core';
 import { TypeScriptFetchClientGeneratorContext, TypeScriptFetchClientGeneratorOutput } from './models';
+import { ts } from '../../../ast';
 import { TypeScriptFileBuilder } from '../../../file-builder';
 import { TypeScriptFileGenerator } from '../../file-generator';
 type Context = TypeScriptFetchClientGeneratorContext;
@@ -10,27 +11,14 @@ export interface TypeScriptFetchClientGenerator<TOutput extends Output = Output>
 }
 export declare class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerator<Context, Output> implements TypeScriptFetchClientGenerator {
     generate(ctx: Context): Output;
-    protected generateInterface(ctx: Context, builder: Builder): void;
-    protected generateInterfaceDocumentation(ctx: Context, builder: Builder): void;
-    protected generateInterfaceSignature(ctx: Context, builder: Builder): void;
-    protected generateInterfaceContent(ctx: Context, builder: Builder): void;
-    protected generateInterfaceServiceMethod(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateDefaultOptions(ctx: Context, builder: Builder): void;
-    protected generateClass(ctx: Context, builder: Builder): void;
-    protected generateClassDocumentation(ctx: Context, builder: Builder): void;
-    protected generateClassSignature(ctx: Context, builder: Builder): void;
-    protected generateClassContent(ctx: Context, builder: Builder): void;
-    protected generateClassFields(ctx: Context, builder: Builder): void;
-    protected generateClassConstructor(ctx: Context, builder: Builder): void;
-    protected generateClassConstructorContent(ctx: Context, builder: Builder): void;
-    protected generateClassServiceMethod(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateServiceMethodDocumentation(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateServiceMethodSignature(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateServiceMethodParameters(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateServiceMethodReturnValue(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected generateTypedResponse(ctx: Context, builder: Builder, schema: ApiSchema | undefined): void;
-    protected generateServiceMethodContent(ctx: Context, builder: Builder, endpoint: ApiEndpoint): void;
-    protected getTypeName(ctx: Context, builder: Builder, schemaId: string | undefined, fallback?: string): string;
+    protected getInterfaceFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getInterface(ctx: Context): ts.Interface<Builder>;
+    protected getInterfaceEndpointMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder>;
+    protected getClassFileContent(ctx: Context): AppendValueGroup<Builder>;
+    protected getDefaultOptionsConstant(ctx: Context): ts.Variable<Builder>;
+    protected getClass(ctx: Context): ts.Class<Builder>;
+    protected getServiceMethod(ctx: Context, endpoint: ApiEndpoint): ts.Method<Builder>;
+    protected getSchemaType(ctx: Context, schema: ApiSchema | undefined, fallback?: ts.Type<Builder>): ts.Type<Builder>;
     protected shouldGenerateInterface(ctx: Context): boolean;
     protected shouldGenerateClass(ctx: Context): boolean;
     protected getInterfaceName(ctx: Context): string;

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

@@ -1,4 +1,5 @@
 import { ApiService, DefaultGenerationProviderConfig, OpenApiServicesGenerationProviderContext, StringCasing, StringCasingWithOptions, Nullable } from '@goast/core';
+import { getReferenceFactories } from './refs';
 import { TypeScriptComponentOutput } from '../../../common-results';
 import { TypeScriptGeneratorConfig } from '../../../config';
 import { TypeScriptModelsGeneratorOutput } from '../../models/models';
@@ -28,7 +29,9 @@ export type TypeScriptFetchClientGeneratorOutput = {
     class?: Omit<TypeScriptComponentOutput, 'additionalImports'>;
     interface?: Omit<TypeScriptComponentOutput, 'additionalImports'>;
 };
-export type TypeScriptFetchClientsGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptFetchClientsGeneratorInput, TypeScriptFetchClientsGeneratorOutput, TypeScriptFetchClientsGeneratorConfig, TypeScriptFetchClientGeneratorOutput>;
+export type TypeScriptFetchClientsGeneratorContext = OpenApiServicesGenerationProviderContext<TypeScriptFetchClientsGeneratorInput, TypeScriptFetchClientsGeneratorOutput, TypeScriptFetchClientsGeneratorConfig, TypeScriptFetchClientGeneratorOutput> & {
+    refs: ReturnType<typeof getReferenceFactories>;
+};
 export type TypeScriptFetchClientGeneratorContext = TypeScriptFetchClientsGeneratorContext & {
     readonly service: ApiService;
 };

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

@@ -0,0 +1,23 @@
+import { TypeScriptFetchClientsGeneratorConfig } from './models';
+import { ts } from '../../../ast';
+export declare function getReferenceFactories(options: TypeScriptFetchClientsGeneratorConfig): {
+    typedResponse: (<TBuilder extends import("@goast/core").SourceBuilder<never>>(generics: [ts.Type<TBuilder>]) => ts.Reference<TBuilder, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+        infer: <TBuilder_1 extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder_1, never>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    fetchClientOptions: (<TBuilder_2 extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder_2, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+    urlBuilder: (<TBuilder_2 extends import("@goast/core").SourceBuilder<never>>() => ts.Reference<TBuilder_2, never>) & {
+        refName: string;
+        moduleNameOrfilePath: import("@goast/core").Nullable<string>;
+    } & {
+        moduleNameOrfilePath: string;
+    };
+};

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

@@ -1,20 +1,28 @@
 import { SourceBuilderOptions, StringBuilder } from '@goast/core';
 import { TypeScriptImport, TypeScriptImportKind } from './common-results';
-import { TypeScriptFileBuilder } from './file-builder';
 import { ImportModuleTransformer } from './utils';
+export type ImportExportCollectionOptions = {
+    filePath?: string;
+    importModuleTransformer: ImportModuleTransformer;
+    useSingleQuotes: boolean;
+};
+export declare const defaultImportExportCollectionOptions: ImportExportCollectionOptions;
 export declare class ImportExportCollection {
     private readonly _imports;
     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;
     addExport(exportName: string, fromModule: string): void;
     clear(): void;
-    toString(options: Partial<SourceBuilderOptions>, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): string;
-    writeTo(builder: StringBuilder, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): void;
-    writeTo(builder: TypeScriptFileBuilder): void;
-    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export', data: (readonly [string, TypeScriptImportKind, string[]])[]): void;
+    toString(options: Partial<SourceBuilderOptions>): string;
+    writeTo(builder: StringBuilder): void;
+    protected writeImportsExports(builder: StringBuilder, keyword: 'import' | 'export', 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[]])[];
     protected getImportKind(fromModule: string): TypeScriptImportKind;
     protected resolveModulePath(fromModule: string, filePath: string | undefined, importModuleTransformer: ImportModuleTransformer): [string, TypeScriptImportKind];

package/assets/client/fetch/types.ts

@@ -1,14 +0,0 @@
-type _VoidResponse = Omit<Response, 'json'> & {
-  isVoidResponse: true;
-};
-type _TypedResponse<T> = Response & {
-  json(): Promise<T>;
-  isVoidResponse: false;
-};
-export type TypedResponse<T> = void extends T ? _VoidResponse : _TypedResponse<T>;
-
-export type FetchClientOptions = {
-  baseUrl?: string;
-  fetch?: typeof fetch;
-  headers?: Record<string, string>;
-};

package/assets/service/angular/api-configuration.ts

@@ -1,18 +0,0 @@
-import { Injectable } from '@angular/core';
-
-/**
- * Global configuration
- */
-@Injectable({
-  providedIn: 'root',
-})
-export class ApiConfiguration {
-  rootUrl: string = '@ROOT_URL@';
-}
-
-/**
- * Parameters for `ApiModule.forRoot()`
- */
-export interface ApiConfigurationParams {
-  rootUrl?: string;
-}

package/assets/service/angular/base-service.ts

@@ -1,29 +0,0 @@
-import { HttpClient } from '@angular/common/http';
-import { Injectable } from '@angular/core';
-
-import { ApiConfiguration } from './api-configuration';
-
-/**
- * Base class for services
- */
-@Injectable()
-export class BaseService {
-  constructor(protected config: ApiConfiguration, protected http: HttpClient) {}
-
-  private _rootUrl: string = '';
-
-  /**
-   * Returns the root url for all operations in this service. If not set directly in this
-   * service, will fallback to `ApiConfiguration.rootUrl`.
-   */
-  get rootUrl(): string {
-    return this._rootUrl || this.config.rootUrl;
-  }
-
-  /**
-   * Sets the root URL for API operations in this service.
-   */
-  set rootUrl(rootUrl: string) {
-    this._rootUrl = rootUrl;
-  }
-}

package/assets/service/angular/response-handlers.ts

@@ -1,127 +0,0 @@
-import { HttpErrorResponse } from '@angular/common/http';
-
-import { StrictHttpResponse } from './strict-http-response';
-
-type Response = { status: string; content: unknown };
-type PickRsp<T extends Response, K extends T['status']> = Exclude<T, Exclude<T, { status: K }>>;
-type ExcludeRsp<T extends Response, K extends T['status']> = Exclude<T, { status: K }>;
-type Handeled<T extends string | number | symbol> = { [K in T]: true };
-type SuccessCode = `2${number}`;
-type SuccessCodes<T extends Response> = Exclude<T['status'], Exclude<T['status'], SuccessCode>>;
-type ErrorCode = `${4 | 5}${number}` | 'other';
-type ErrorCodes<T extends Response> = Exclude<T['status'], Exclude<T['status'], ErrorCode>>;
-type RemoveVoid<T> = T extends void ? never : T;
-
-export class ResponseHandler<
-  I extends Response,
-  S extends I,
-  E extends Handeled<Exclude<I['status'], S['status']>>,
-  O
-> {
-  private readonly _dummy?: E;
-  private readonly _response: I;
-  private _isHandeled = false;
-  public result: O | PromiseLike<O> = undefined!;
-
-  constructor(response: I) {
-    this._response = response;
-  }
-
-  public handle<T extends Exclude<S['status'], 'other'>, U = undefined>(
-    status: T[] | T,
-    handler?: (r: PickRsp<S, T>, status: string) => U | PromiseLike<U>
-  ) {
-    const newThis = this.as<ExcludeRsp<S, T>, Handeled<T | keyof E>, RemoveVoid<U>>();
-    const matches = Array.isArray(status)
-      ? (status as string[]).indexOf(this._response.status.toString()) >= 0
-      : this._response.status.toString() === status;
-    if (matches && !this._isHandeled) {
-      this._isHandeled = true;
-      if (handler) {
-        newThis.result = handler(this._response as PickRsp<S, T>, this._response.status) as
-          | RemoveVoid<U>
-          | PromiseLike<RemoveVoid<U>>;
-      }
-    }
-    return newThis;
-  }
-
-  public handleSuccess<T = undefined>(handler?: (r: PickRsp<S, SuccessCode>, status: string) => T | PromiseLike<T>) {
-    const newThis = this.as<ExcludeRsp<S, SuccessCode>, Handeled<SuccessCodes<S> | keyof E>, RemoveVoid<T>>();
-    const matches = this._response.status.startsWith('2');
-    if (matches && !this._isHandeled) {
-      this._isHandeled = true;
-      if (handler) {
-        newThis.result = handler(this._response as PickRsp<S, SuccessCode>, this._response.status) as
-          | RemoveVoid<T>
-          | PromiseLike<RemoveVoid<T>>;
-      }
-    }
-    return newThis;
-  }
-
-  public handleError<T = undefined>(handler?: (r: PickRsp<S, ErrorCode>, status: string) => T | PromiseLike<T>) {
-    const newThis = this.as<ExcludeRsp<S, ErrorCode>, Handeled<ErrorCodes<S> | keyof E>, RemoveVoid<T>>();
-    const matches = this._response.status.startsWith('4') || this._response.status.startsWith('5');
-    if (matches && !this._isHandeled) {
-      this._isHandeled = true;
-      if (handler) {
-        newThis.result = handler(this._response as PickRsp<S, ErrorCode>, this._response.status) as
-          | RemoveVoid<T>
-          | PromiseLike<RemoveVoid<T>>;
-      }
-    }
-    return newThis;
-  }
-
-  public throwOnError() {
-    const newThis = this.as<ExcludeRsp<S, ErrorCode>, Handeled<ErrorCodes<S> | keyof E>, never>();
-    const matches = this._response.status.startsWith('4') || this._response.status.startsWith('5');
-    if (matches && !this._isHandeled) {
-      throw new UnhandeledResponseError(this._response);
-    }
-    return newThis;
-  }
-
-  private as<NewS extends I, NewE extends Handeled<Exclude<I['status'], NewS['status']>>, NewO>() {
-    return this as unknown as ResponseHandler<I, NewS, NewE, O | NewO>;
-  }
-}
-
-export class UnhandeledResponseError extends Error {
-  public readonly response: Response;
-
-  constructor(response: Response) {
-    super(`The response with status code '${response.status}' was not handeled.`, { cause: response });
-    this.response = response;
-  }
-}
-
-export type ResponseHandlerFn<T extends Response, O> = (
-  handler: ResponseHandler<T, T, object, never>
-) => ResponseHandler<T, never, { [K in T['status']]: true }, O>;
-
-export function handleResponse<R extends Response, O>(
-  response: Promise<StrictHttpResponse<unknown>>,
-  handler: ResponseHandlerFn<R, O>
-): Promise<O> {
-  return response
-    .then(
-      (r: StrictHttpResponse<unknown>) =>
-        <R>{
-          status: r.status.toString(),
-          content: r.body,
-        }
-    )
-    .catch((e: HttpErrorResponse) => {
-      if (!e.status) throw e;
-      return <R>{
-        status: e.status.toString(),
-        content: e.error,
-      };
-    })
-    .then((r: R) => {
-      const h = new ResponseHandler<R, R, object, never>(r);
-      return handler(h).result;
-    });
-}

package/assets/service/angular/strict-http-response.ts

@@ -1,8 +0,0 @@
-import { HttpResponse } from '@angular/common/http';
-
-/**
- * Constrains the http response to not have the body defined as `T | null`, but `T` only.
- */
-export type StrictHttpResponse<T> = HttpResponse<T> & {
-  readonly body: T;
-};