@goast/typescript 0.3.8-beta1 → 0.3.8

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

@@ -1,260 +1,260 @@
-import { EasyNetworkStub } from 'easy-network-stub';
-
-import type { HttpMethod, RouteResponseCallback, ErrorResponse } 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>,
-  ): void {
-    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>,
-  ) => void {
-    return <Route extends string>(method: HttpMethod, route: Route, response: RouteResponseCallback<Route, T>) => {
-      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['_config'].stubs = [];
-  }
-
-  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 { EasyNetworkStub } from 'easy-network-stub';
+
+import type { HttpMethod, RouteResponseCallback, ErrorResponse } 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>,
+  ): void {
+    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>,
+  ) => void {
+    return <Route extends string>(method: HttpMethod, route: Route, response: RouteResponseCallback<Route, T>) => {
+      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['_config'].stubs = [];
+  }
+
+  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/cjs/lib/generators/services/angular-services/angular-service-generator.js

@@ -231,13 +231,13 @@ class DefaultTypeScriptAngularServiceGenerator extends file_generator_1.TypeScri
                     }
                     : null,
                 '',
-                (0, core_1.builderTemplate) `return ${ctx.refs.waitForResponse([responseModelType])}(${core_1.builderTemplate.indent `
-              this.http.request(rb.build({${core_1.builderTemplate.indent `
-                responseType: ${ast_1.ts.string(responseType)},
-                accept: ${ast_1.ts.string(accept)},
-                context,`}
-              })),
-              {${core_1.builderTemplate.indent `
+                (0, core_1.builderTemplate) `return ${ctx.refs.waitForResponse([responseModelType])}(${core_1.builderTemplate.indent `
+              this.http.request(rb.build({${core_1.builderTemplate.indent `
+                responseType: ${ast_1.ts.string(responseType)},
+                accept: ${ast_1.ts.string(accept)},
+                context,`}
+              })),
+              {${core_1.builderTemplate.indent `
                 errorResponseTypes: ${ast_1.ts.object({
                     members: [
                         ...Object.entries(this.getEndpointStatusCodes(ctx, endpoint))
@@ -246,8 +246,8 @@ class DefaultTypeScriptAngularServiceGenerator extends file_generator_1.TypeScri
                             return ast_1.ts.property(key, { value: ast_1.ts.string(value.parser) });
                         }),
                     ],
-                })}`}
-              }`}
+                })}`}
+              }`}
             )`,
             ], '\n'),
         });

package/cjs/lib/generators/services/easy-network-stub/easy-network-stub-generator.js

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

package/cjs/lib/generators/services/fetch-clients/fetch-client-generator.js

@@ -136,7 +136,7 @@ class DefaultTypeScriptFetchClientGenerator extends file_generator_1.TypeScriptF
         const method = this.getInterfaceEndpointMethod(ctx, endpoint);
         method.accessModifier = 'public';
         method.body = (0, core_1.appendValueGroup)([
-            (0, core_1.builderTemplate) `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${core_1.builderTemplate.indent `
+            (0, core_1.builderTemplate) `const url = new ${ctx.refs.urlBuilder()}(this.options.baseUrl)${core_1.builderTemplate.indent `
           .withPath(${ast_1.ts.string(endpoint.path)})${(b) => b.forEach(endpoint.parameters, (b, p) => {
                 switch (p.target) {
                     case 'path':
@@ -146,7 +146,7 @@ class DefaultTypeScriptFetchClientGenerator extends file_generator_1.TypeScriptF
                         b.append((0, core_1.builderTemplate) `\n.withQueryParam(${ast_1.ts.string(p.name)}, params.${(0, core_1.toCasing)(p.name, ctx.config.paramNameCasing)})`);
                         break;
                 }
-            })}
+            })}
           .build();`}`,
             (0, core_1.builderTemplate) `const response = (this.options.fetch ?? fetch)(url, ${ast_1.ts.object({
                 members: [

package/cjs/lib/generators/services/k6-clients/k6-client-generator.js

@@ -189,7 +189,7 @@ class DefaultTypeScriptK6ClientGenerator extends file_generator_1.TypeScriptFile
                         ],
                     }),
                     parameters: [ast_1.ts.constructorParameter('rootUrl'), ast_1.ts.constructorParameter('defaultK6ParamsFactory')],
-                    body: (0, core_1.builderTemplate) `this.rootUrl = rootUrl;
+                    body: (0, core_1.builderTemplate) `this.rootUrl = rootUrl;
                   this._defaultK6ParamsFactory = defaultK6ParamsFactory;`,
                 }),
                 ...ctx.service.endpoints.map((e) => this.getEndpointMethod(ctx, e)),
@@ -248,11 +248,11 @@ class DefaultTypeScriptK6ClientGenerator extends file_generator_1.TypeScriptFile
                     }
                     : null,
                 '',
-                (0, core_1.builderTemplate) `return /** @type {${returnType}} */ (${core_1.builderTemplate.indent `
-              ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${core_1.builderTemplate.indent `
-                accept: ${ast_1.ts.string(accept)},
-                params: this.getK6Params(k6Params),`}
-              })`}
+                (0, core_1.builderTemplate) `return /** @type {${returnType}} */ (${core_1.builderTemplate.indent `
+              ${ctx.config.async ? 'await rb.buildAsync' : 'rb.build'}({${core_1.builderTemplate.indent `
+                accept: ${ast_1.ts.string(accept)},
+                params: this.getK6Params(k6Params),`}
+              })`}
             );`,
             ], '\n'),
         });

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

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