@goast/typescript 0.7.5 → 0.8.0-beta.1

package/assets/stubs/easy-network-stub/easy-network-stub.utils.ts

@@ -1,257 +1,257 @@
-import type { EasyNetworkStub, ErrorResponse, HttpMethod, RouteResponseCallback, StubHandle } from 'easy-network-stub';
-
-/**
- * Options for the `EasyNetworkStubWrapper`.
- */
-export type EasyNetworkStubWrapperOptions = {
-  /**
-   * Delay in milliseconds before responding.
-   * @default 0
-   */
-  delay: number;
-  /**
-   * Whether to log requests to the console.
-   * @default false
-   */
-  logRequests: boolean;
-  /**
-   * Whether to log responses to the console.
-   * @default false
-   */
-  logResponses: boolean;
-  /**
-   * Whether to remember requests. Remebered requests can be accessed via the `requests` property.
-   * @default false
-   */
-  rememberRequests: boolean;
-  /**
-   * Function to call when a response is sent.
-   * @param response The response that was sent.
-   * @default undefined
-   */
-  responseCallback?: (response: unknown) => void;
-  /**
-   * A prefix to add to the URL in log messages.
-   * @default /api/
-   */
-  logUrlPrefix: string;
-};
-
-/**
- * Represents a request intercepted by the `EasyNetworkStubWrapper`.
- */
-export type StubRequestItem = {
-  /**
-   * The HTTP method of the request.
-   */
-  method: HttpMethod;
-  /**
-   * The route of the request.
-   */
-  route: string;
-  /**
-   * The request information provided by `easy-network-stub`.
-   */
-  request: StubRequestInfo;
-};
-
-/**
- * Represents the request information provided by `easy-network-stub`.
- */
-export type StubRequestInfo<TRoute extends string = string, TBody = unknown> = Parameters<
-  RouteResponseCallback<TRoute, TBody>
->[0];
-
-/**
- * A strict version of `RouteResponseCallback` that allows for a responder to be passed as the first argument.
- */
-export type StrictRouteResponseCallback<T, P extends string, R> = (
-  respondWith: R,
-  ...args: Parameters<RouteResponseCallback<P, T>>
-) => ErrorResponse<any> | Promise<ErrorResponse<any>>;
-
-type _UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
-type __StubResponder<T extends Record<number, unknown>, S> = S extends number
-  ? [T[S]] extends [never] ? (statusCode: S) => ErrorResponse<T[S]>
-  : (statusCode: S, content: T[S]) => ErrorResponse<T[S]>
-  : never;
-type _StubResponder<T extends Record<number, unknown>> = _UnionToIntersection<__StubResponder<T, keyof T>>;
-const untypedResponder = (statusCode: number, content?: unknown) => ({ statusCode, content });
-
-/**
- * Gets the responder function typed to a specific set of status codes.
- * @returns The responder function.
- */
-export function getStubResponder<T extends Record<number, unknown>>(): _StubResponder<T> {
-  return untypedResponder as _StubResponder<T>;
-}
-
-/**
- * Wrapper for `EasyNetworkStub` that adds additional functionality.
- */
-export class EasyNetworkStubWrapper {
-  private _requests: StubRequestItem[] = [];
-
-  /**
-   * The options for the wrapper.
-   */
-  public readonly options: Readonly<EasyNetworkStubWrapperOptions>;
-
-  /**
-   * The requests that have been intercepted by the wrapper.
-   */
-  public get requests(): ReadonlyArray<StubRequestItem> {
-    return this._requests;
-  }
-
-  constructor(
-    public readonly wrappedStub: EasyNetworkStub,
-    options?: Partial<EasyNetworkStubWrapperOptions>,
-  ) {
-    this.options = {
-      delay: options?.delay ?? 0,
-      logRequests: options?.logRequests ?? false,
-      logResponses: options?.logResponses ?? false,
-      rememberRequests: options?.rememberRequests ?? false,
-      responseCallback: options?.responseCallback,
-      logUrlPrefix: options?.logUrlPrefix ?? '/api/',
-    };
-  }
-
-  /**
-   * Add a single api stub to your intercepted routes.
-   * @param method The http method that should be stubbed
-   * @param route The route that should be stubbed. Supports parameters in the form of {name:type}.
-   * @param response The callback in which you can process the request and reply with the stub. When a Promise is returned, the stub response will be delayed until it is resolved.
-   */
-  public stub<Route extends string>(
-    method: HttpMethod,
-    route: Route,
-    response: RouteResponseCallback<Route, unknown>,
-  ): StubHandle {
-    return this.wrappedStub.stub<Route>(method, route, async (request) => {
-      if (this.options.delay > 0) await sleep(this.options.delay);
-      return await this.runRequest(method, route, response, request);
-    });
-  }
-
-  /**
-   * The stub2 method provides a way to set the type of the body that is sent.
-   * Due to restrictions in TypeScript (https://github.com/microsoft/TypeScript/issues/10571, https://github.com/Microsoft/TypeScript/pull/26349),
-   * We have to hacke a bit here. Calling stub2<T>() will return the stub method with a body of type T.
-   *
-   * Usage:
-   * ```
-   * .stub2<MyRequest>()('GET', '/api/test', ({ body }) => {
-   *   // body is of type MyRequest
-   * });
-   * ```
-   * @returns The stub method with a body of type T.
-   */
-  public stub2<T>(): <Route extends string>(
-    method: HttpMethod,
-    route: Route,
-    response: RouteResponseCallback<Route, T>,
-  ) => StubHandle {
-    return <Route extends string>(method: HttpMethod, route: Route, response: RouteResponseCallback<Route, T>) => {
-      return this.wrappedStub.stub2<T>()<Route>(method, route, async (request) => {
-        if (this.options.delay > 0) await sleep(this.options.delay);
-        return await this.runRequest(method, route, response, request);
-      });
-    };
-  }
-
-  /**
-   * Reset the stubs and requests.
-   */
-  public reset(): void {
-    this._requests = [];
-    this.wrappedStub.unregisterAll();
-  }
-
-  private async runRequest<Route extends string, T>(
-    method: HttpMethod,
-    route: Route,
-    response: RouteResponseCallback<Route, T>,
-    request: StubRequestInfo<Route, T>,
-  ): Promise<unknown> {
-    if (this.options.rememberRequests) {
-      this._requests.push({ method, route, request });
-    }
-    this.log('request', method, route, request, '#7FFFFF');
-    try {
-      const r = await response(request);
-      this.options.responseCallback?.(r);
-      this.log('response', method, route, r, '#7FFF8E');
-      return r;
-    } catch (error: unknown) {
-      this.options.responseCallback?.(error);
-      if (isHttpResponse(error) && error.statusCode >= 200 && error.statusCode < 300) {
-        this.log('response', method, route, error.content, '#7FFF8E');
-        throw error;
-      } else {
-        const isError = isHttpResponse(error) && error.statusCode >= 400 && error.statusCode < 600;
-        this.log('response', method, route, error, isError ? '#FF7F7F' : '7F7F7F');
-        throw error;
-      }
-    }
-  }
-
-  private log(type: 'request' | 'response', method: HttpMethod, route: string, data: unknown, color: string) {
-    if (type === 'request' && !this.options.logRequests) return;
-    if (type === 'response' && !this.options.logResponses) return;
-    const typeDisplay = type === 'request' ? ' [req]' : '[resp]';
-    const strippedRoute = route.match(/[^?]*(?=\?)?/)?.[0];
-    console.log(`%c${typeDisplay} ${method}: ${this.options.logUrlPrefix}${strippedRoute}`, `color:${color};`, data);
-  }
-}
-
-/**
- * Base class for generated easy network stubs.
- */
-export class EasyNetworkStubBase {
-  protected readonly stubWrapper: EasyNetworkStubWrapper;
-  protected readonly ownsStubWrapper: boolean;
-
-  constructor(stub: EasyNetworkStub | EasyNetworkStubWrapper, options?: EasyNetworkStubWrapperOptions) {
-    this.stubWrapper = stub instanceof EasyNetworkStubWrapper ? stub : new EasyNetworkStubWrapper(stub, options);
-    this.ownsStubWrapper = !(stub instanceof EasyNetworkStubWrapper);
-  }
-
-  public reset() {
-    if (this.ownsStubWrapper) {
-      this.stubWrapper.reset();
-    }
-  }
-}
-
-export type EasyNetworkStubGroup<Group, GroupContainer> = Group & {
-  (stubActions: (stubs: Group) => void): GroupContainer;
-};
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-declare interface GroupType<T> extends Function {
-  new (stubWrapper: EasyNetworkStubWrapper): T;
-}
-
-export function createEasyNetworkStubGroup<GroupContainer, Group>(
-  container: GroupContainer,
-  stubWrapper: EasyNetworkStubWrapper,
-  groupType: GroupType<Group>,
-): EasyNetworkStubGroup<Group, GroupContainer> {
-  const group = new groupType(stubWrapper);
-  const groupFn = (stubActions: (stubs: Group) => void) => {
-    stubActions(group);
-    return container;
-  };
-  Object.setPrototypeOf(groupFn, groupType.prototype);
-  return Object.assign(groupFn, group);
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function isHttpResponse(value: unknown): value is ErrorResponse<unknown> {
-  return typeof value === 'object' && value !== null && 'statusCode' in value;
-}
+import type { EasyNetworkStub, ErrorResponse, HttpMethod, RouteResponseCallback, StubHandle } from 'easy-network-stub';
+
+/**
+ * Options for the `EasyNetworkStubWrapper`.
+ */
+export type EasyNetworkStubWrapperOptions = {
+  /**
+   * Delay in milliseconds before responding.
+   * @default 0
+   */
+  delay: number;
+  /**
+   * Whether to log requests to the console.
+   * @default false
+   */
+  logRequests: boolean;
+  /**
+   * Whether to log responses to the console.
+   * @default false
+   */
+  logResponses: boolean;
+  /**
+   * Whether to remember requests. Remebered requests can be accessed via the `requests` property.
+   * @default false
+   */
+  rememberRequests: boolean;
+  /**
+   * Function to call when a response is sent.
+   * @param response The response that was sent.
+   * @default undefined
+   */
+  responseCallback?: (response: unknown) => void;
+  /**
+   * A prefix to add to the URL in log messages.
+   * @default /api/
+   */
+  logUrlPrefix: string;
+};
+
+/**
+ * Represents a request intercepted by the `EasyNetworkStubWrapper`.
+ */
+export type StubRequestItem = {
+  /**
+   * The HTTP method of the request.
+   */
+  method: HttpMethod;
+  /**
+   * The route of the request.
+   */
+  route: string;
+  /**
+   * The request information provided by `easy-network-stub`.
+   */
+  request: StubRequestInfo;
+};
+
+/**
+ * Represents the request information provided by `easy-network-stub`.
+ */
+export type StubRequestInfo<TRoute extends string = string, TBody = unknown> = Parameters<
+  RouteResponseCallback<TRoute, TBody>
+>[0];
+
+/**
+ * A strict version of `RouteResponseCallback` that allows for a responder to be passed as the first argument.
+ */
+export type StrictRouteResponseCallback<T, P extends string, R> = (
+  respondWith: R,
+  ...args: Parameters<RouteResponseCallback<P, T>>
+) => ErrorResponse<any> | Promise<ErrorResponse<any>>;
+
+type _UnionToIntersection<U> = (U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never;
+type __StubResponder<T extends Record<number, unknown>, S> = S extends number
+  ? [T[S]] extends [never] ? (statusCode: S) => ErrorResponse<T[S]>
+  : (statusCode: S, content: T[S]) => ErrorResponse<T[S]>
+  : never;
+type _StubResponder<T extends Record<number, unknown>> = _UnionToIntersection<__StubResponder<T, keyof T>>;
+const untypedResponder = (statusCode: number, content?: unknown) => ({ statusCode, content });
+
+/**
+ * Gets the responder function typed to a specific set of status codes.
+ * @returns The responder function.
+ */
+export function getStubResponder<T extends Record<number, unknown>>(): _StubResponder<T> {
+  return untypedResponder as _StubResponder<T>;
+}
+
+/**
+ * Wrapper for `EasyNetworkStub` that adds additional functionality.
+ */
+export class EasyNetworkStubWrapper {
+  private _requests: StubRequestItem[] = [];
+
+  /**
+   * The options for the wrapper.
+   */
+  public readonly options: Readonly<EasyNetworkStubWrapperOptions>;
+
+  /**
+   * The requests that have been intercepted by the wrapper.
+   */
+  public get requests(): ReadonlyArray<StubRequestItem> {
+    return this._requests;
+  }
+
+  constructor(
+    public readonly wrappedStub: EasyNetworkStub,
+    options?: Partial<EasyNetworkStubWrapperOptions>,
+  ) {
+    this.options = {
+      delay: options?.delay ?? 0,
+      logRequests: options?.logRequests ?? false,
+      logResponses: options?.logResponses ?? false,
+      rememberRequests: options?.rememberRequests ?? false,
+      responseCallback: options?.responseCallback,
+      logUrlPrefix: options?.logUrlPrefix ?? '/api/',
+    };
+  }
+
+  /**
+   * Add a single api stub to your intercepted routes.
+   * @param method The http method that should be stubbed
+   * @param route The route that should be stubbed. Supports parameters in the form of {name:type}.
+   * @param response The callback in which you can process the request and reply with the stub. When a Promise is returned, the stub response will be delayed until it is resolved.
+   */
+  public stub<Route extends string>(
+    method: HttpMethod,
+    route: Route,
+    response: RouteResponseCallback<Route, unknown>,
+  ): StubHandle {
+    return this.wrappedStub.stub<Route>(method, route, async (request) => {
+      if (this.options.delay > 0) await sleep(this.options.delay);
+      return await this.runRequest(method, route, response, request);
+    });
+  }
+
+  /**
+   * The stub2 method provides a way to set the type of the body that is sent.
+   * Due to restrictions in TypeScript (https://github.com/microsoft/TypeScript/issues/10571, https://github.com/Microsoft/TypeScript/pull/26349),
+   * We have to hacke a bit here. Calling stub2<T>() will return the stub method with a body of type T.
+   *
+   * Usage:
+   * ```
+   * .stub2<MyRequest>()('GET', '/api/test', ({ body }) => {
+   *   // body is of type MyRequest
+   * });
+   * ```
+   * @returns The stub method with a body of type T.
+   */
+  public stub2<T>(): <Route extends string>(
+    method: HttpMethod,
+    route: Route,
+    response: RouteResponseCallback<Route, T>,
+  ) => StubHandle {
+    return <Route extends string>(method: HttpMethod, route: Route, response: RouteResponseCallback<Route, T>) => {
+      return this.wrappedStub.stub2<T>()<Route>(method, route, async (request) => {
+        if (this.options.delay > 0) await sleep(this.options.delay);
+        return await this.runRequest(method, route, response, request);
+      });
+    };
+  }
+
+  /**
+   * Reset the stubs and requests.
+   */
+  public reset(): void {
+    this._requests = [];
+    this.wrappedStub.unregisterAll();
+  }
+
+  private async runRequest<Route extends string, T>(
+    method: HttpMethod,
+    route: Route,
+    response: RouteResponseCallback<Route, T>,
+    request: StubRequestInfo<Route, T>,
+  ): Promise<unknown> {
+    if (this.options.rememberRequests) {
+      this._requests.push({ method, route, request });
+    }
+    this.log('request', method, route, request, '#7FFFFF');
+    try {
+      const r = await response(request);
+      this.options.responseCallback?.(r);
+      this.log('response', method, route, r, '#7FFF8E');
+      return r;
+    } catch (error: unknown) {
+      this.options.responseCallback?.(error);
+      if (isHttpResponse(error) && error.statusCode >= 200 && error.statusCode < 300) {
+        this.log('response', method, route, error.content, '#7FFF8E');
+        throw error;
+      } else {
+        const isError = isHttpResponse(error) && error.statusCode >= 400 && error.statusCode < 600;
+        this.log('response', method, route, error, isError ? '#FF7F7F' : '7F7F7F');
+        throw error;
+      }
+    }
+  }
+
+  private log(type: 'request' | 'response', method: HttpMethod, route: string, data: unknown, color: string) {
+    if (type === 'request' && !this.options.logRequests) return;
+    if (type === 'response' && !this.options.logResponses) return;
+    const typeDisplay = type === 'request' ? ' [req]' : '[resp]';
+    const strippedRoute = route.match(/[^?]*(?=\?)?/)?.[0];
+    console.log(`%c${typeDisplay} ${method}: ${this.options.logUrlPrefix}${strippedRoute}`, `color:${color};`, data);
+  }
+}
+
+/**
+ * Base class for generated easy network stubs.
+ */
+export class EasyNetworkStubBase {
+  protected readonly stubWrapper: EasyNetworkStubWrapper;
+  protected readonly ownsStubWrapper: boolean;
+
+  constructor(stub: EasyNetworkStub | EasyNetworkStubWrapper, options?: EasyNetworkStubWrapperOptions) {
+    this.stubWrapper = stub instanceof EasyNetworkStubWrapper ? stub : new EasyNetworkStubWrapper(stub, options);
+    this.ownsStubWrapper = !(stub instanceof EasyNetworkStubWrapper);
+  }
+
+  public reset() {
+    if (this.ownsStubWrapper) {
+      this.stubWrapper.reset();
+    }
+  }
+}
+
+export type EasyNetworkStubGroup<Group, GroupContainer> = Group & {
+  (stubActions: (stubs: Group) => void): GroupContainer;
+};
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+declare interface GroupType<T> extends Function {
+  new (stubWrapper: EasyNetworkStubWrapper): T;
+}
+
+export function createEasyNetworkStubGroup<GroupContainer, Group>(
+  container: GroupContainer,
+  stubWrapper: EasyNetworkStubWrapper,
+  groupType: GroupType<Group>,
+): EasyNetworkStubGroup<Group, GroupContainer> {
+  const group = new groupType(stubWrapper);
+  const groupFn = (stubActions: (stubs: Group) => void) => {
+    stubActions(group);
+    return container;
+  };
+  Object.setPrototypeOf(groupFn, groupType.prototype);
+  return Object.assign(groupFn, group);
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isHttpResponse(value: unknown): value is ErrorResponse<unknown> {
+  return typeof value === 'object' && value !== null && 'statusCode' in value;
+}

package/esm/src/generators/services/angular-services/angular-service-generator.js

@@ -235,13 +235,13 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
                     ], '\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 `
+                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))
@@ -250,8 +250,8 @@ export class DefaultTypeScriptAngularServiceGenerator extends TypeScriptFileGene
                             return ts.property(key, { value: ts.string(value.parser) });
                         }),
                     ],
-                })}`}
-              }`}
+                })}`}
+              }`}
             )`,
             ], '\n'),
         });

package/esm/src/generators/services/easy-network-stub/easy-network-stub-generator.js

@@ -99,15 +99,15 @@ export class DefaultTypeScriptEasyNetworkStubGenerator extends TypeScriptFileGen
             ],
             returnType: 'this',
             body: appendValueGroup([
-                s `this.stubWrapper.stub2<${requestType}>()(${s.indent `
-              ${ts.string(endpoint.method.toUpperCase())},
-              ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
-              async (request) => {${s.indent `
-                if (this.stubWrapper.options.rememberRequests) {${s.indent `
-                  this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.push(request);`}
-                }
-                throw await response(${this.getResponderVariableName(ctx, endpoint)}, request);`}
-              }`}
+                s `this.stubWrapper.stub2<${requestType}>()(${s.indent `
+              ${ts.string(endpoint.method.toUpperCase())},
+              ${this.getStubClassName(ctx)}.${this.getEndpointPathPropertyName(ctx, endpoint)},
+              async (request) => {${s.indent `
+                if (this.stubWrapper.options.rememberRequests) {${s.indent `
+                  this.${this.getEndpointRequestsFieldName(ctx, endpoint)}.push(request);`}
+                }
+                throw await response(${this.getResponderVariableName(ctx, endpoint)}, request);`}
+              }`}
             );`,
                 'return this;',
             ], '\n'),

package/esm/src/generators/services/fetch-clients/fetch-client-generator.js

@@ -140,7 +140,7 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
         const method = this.getInterfaceEndpointMethod(ctx, endpoint);
         method.accessModifier = 'public';
         method.body = appendValueGroup([
-            s `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent `
+            s `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${s.indent `
           .withPath(${ts.string(endpoint.path)})${(b) => b.forEach(endpoint.parameters, (b, p) => {
                 switch (p.target) {
                     case 'path':
@@ -150,11 +150,11 @@ export class DefaultTypeScriptFetchClientGenerator extends TypeScriptFileGenerat
                         b.append(s `\n.withQueryParam(${ts.string(p.name)}, params.${toCasing(p.name, ctx.config.paramNameCasing)})`);
                         break;
                 }
-            })}
+            })}
           .build();`}`,
             'const headers = { ...this.options.headers };',
-            ...endpoint.parameters.filter((x) => x.target === 'header').map((p) => s `if (params && params.${toCasing(p.name, ctx.config.paramNameCasing)} !== undefined) {${s.indent `
-            headers[${ts.string(p.name)}] = String(params.${toCasing(p.name, ctx.config.paramNameCasing)});`}
+            ...endpoint.parameters.filter((x) => x.target === 'header').map((p) => s `if (params && params.${toCasing(p.name, ctx.config.paramNameCasing)} !== undefined) {${s.indent `
+            headers[${ts.string(p.name)}] = String(params.${toCasing(p.name, ctx.config.paramNameCasing)});`}
           }`),
             s `const response = (this.options.fetch ?? fetch)(url, ${ts.object({
                 members: [

package/esm/src/generators/services/k6-clients/k6-client-generator.js

@@ -245,7 +245,7 @@ export class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator
                         ts.constructorParameter('rootUrl', { type: isJs ? undefined : rootUrlType }),
                         ts.constructorParameter('defaultK6ParamsFactory', { type: isJs ? undefined : paramType, optional: true }),
                     ],
-                    body: s `this.rootUrl = rootUrl;
+                    body: s `this.rootUrl = rootUrl;
                   this._defaultK6ParamsFactory = defaultK6ParamsFactory;`,
                 }),
                 ...ctx.service.endpoints.map((e) => this.getEndpointMethod(ctx, e)),
@@ -307,17 +307,17 @@ export class DefaultTypeScriptK6ClientGenerator extends TypeScriptFileGenerator
                     : null,
                 '',
                 ctx.config.language === 'javascript'
-                    ? s `return /** @type {${returnType}} */ (${s.indent `
-                ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent `
-                  accept: ${ts.string(accept)},
-                  params: this.getK6Params(k6Params),`}
-                })`}
+                    ? s `return /** @type {${returnType}} */ (${s.indent `
+                ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent `
+                  accept: ${ts.string(accept)},
+                  params: this.getK6Params(k6Params),`}
+                })`}
               );`
-                    : s `return (${s.indent `
-                ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent `
-                  accept: ${ts.string(accept)},
-                  params: this.getK6Params(k6Params),`}
-                })`}
+                    : s `return (${s.indent `
+                ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${s.indent `
+                  accept: ${ts.string(accept)},
+                  params: this.getK6Params(k6Params),`}
+                })`}
               ) as unknown as ${returnType};`,
             ], '\n'),
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goast/typescript",
-  "version": "0.7.5",
+  "version": "0.8.0-beta.1",
   "description": "Provides gOAst generators for generating TypeScript code from OpenAPI specifications.",
   "author": {
     "name": "Marc Schmidt (MaSch0212)",
@@ -25,7 +25,7 @@
   "dependencies": {
     "tslib": "^2.6.2",
     "fs-extra": "^11.3.3",
-    "@goast/core": "0.5.2"
+    "@goast/core": "0.6.0-beta.1"
   },
   "devDependencies": {
     "@types/node": "^20.9.0",