@tstdl/base 0.85.13 → 0.86.0-beta1

package/http/client/http-client.js

@@ -1,339 +1,318 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var http_client_exports = {};
-__export(http_client_exports, {
-  HttpClient: () => HttpClient
-});
-module.exports = __toCommonJS(http_client_exports);
-var import_response = require("../../api/response.js");
-var import_container = require("../../container/index.js");
-var import_array = require("../../utils/array/array.js");
-var import_base64 = require("../../utils/base64.js");
-var import_encoding = require("../../utils/encoding.js");
-var import_middleware = require("../../utils/middleware.js");
-var import_object = require("../../utils/object/object.js");
-var import_readable_stream_from_promise = require("../../utils/stream/readable-stream-from-promise.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_url_builder = require("../../utils/url-builder.js");
-var import_http_headers = require("../http-headers.js");
-var import_http_error = require("../http.error.js");
-var import_types = require("../types.js");
-var import_http_client_options = require("./http-client-options.js");
-var import_http_client_request = require("./http-client-request.js");
-var import_http_client_adapter = require("./http-client.adapter.js");
-var __decorate = function(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
-    r = Reflect.decorate(decorators, target, key, desc);
-  else
-    for (var i = decorators.length - 1; i >= 0; i--)
-      if (d = decorators[i])
-        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-var __metadata = function(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
-    return Reflect.metadata(k, v);
-};
-var __param = function(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-};
-let HttpClient = class HttpClient2 {
-  adapter;
-  headers;
-  middleware;
-  internalMiddleware;
-  callHandler;
-  options;
-  constructor(adapter, options = {}) {
-    this.adapter = adapter;
-    this.options = options;
-    this.middleware = [...options.middleware ?? []];
-    this.headers = new import_http_headers.HttpHeaders();
-    this.internalMiddleware = [
-      getBuildRequestUrlMiddleware(options.baseUrl),
-      addRequestHeadersMiddleware,
-      ...options.enableErrorHandling ?? true ? [errorMiddleware] : []
-    ];
-    this.updateHandlers();
-  }
-  addMiddleware(middleware) {
-    this.middleware.push(middleware);
-    this.updateHandlers();
-  }
-  setDefaultHeader(name, value) {
-    this.headers.set(name, value);
-  }
-  deleteDefaultHeader(name) {
-    this.headers.remove(name);
-  }
-  async head(url, options) {
-    return this.request("HEAD", url, { ...options });
-  }
-  async get(url, options) {
-    return this.request("GET", url, options);
-  }
-  async getText(url, options) {
-    const response = await this.request("GET", url, { ...options });
-    return response.body.readAsText();
-  }
-  async getJson(url, options) {
-    const response = await this.request("GET", url, { ...options });
-    return response.body.readAsJson();
-  }
-  async getBuffer(url, options) {
-    const response = await this.request("GET", url, { ...options });
-    return response.body.readAsBuffer();
-  }
-  getStream(url, options) {
-    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const response = await this.request("GET", url, { ...options });
-      return response.body.readAsStream();
-    });
-  }
-  getTextStream(url, options) {
-    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const response = await this.request("GET", url, { ...options });
-      return response.body.readAsTextStream();
-    });
-  }
-  getBinaryStream(url, options) {
-    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const response = await this.request("GET", url, { ...options });
-      return response.body.readAsBinaryStream();
-    });
-  }
-  async post(url, options) {
-    return this.request("POST", url, options);
-  }
-  async postText(url, options) {
-    const response = await this.request("POST", url, { ...options });
-    return response.body.readAsText();
-  }
-  async postJson(url, options) {
-    const response = await this.request("POST", url, { ...options });
-    return response.body.readAsJson();
-  }
-  async postBuffer(url, options) {
-    const response = await this.request("POST", url, { ...options });
-    return response.body.readAsBuffer();
-  }
-  postStream(url, options) {
-    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const response = await this.request("POST", url, { ...options });
-      return response.body.readAsBinaryStream();
-    });
-  }
-  async put(url, options) {
-    return this.request("PUT", url, options);
-  }
-  async putText(url, options) {
-    const response = await this.request("PUT", url, { ...options });
-    return response.body.readAsText();
-  }
-  async putJson(url, options) {
-    const response = await this.request("PUT", url, { ...options });
-    return response.body.readAsJson();
-  }
-  async putBuffer(url, options) {
-    const response = await this.request("PUT", url, { ...options });
-    return response.body.readAsBuffer();
-  }
-  putStream(url, options) {
-    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const response = await this.request("PUT", url, { ...options });
-      return response.body.readAsBinaryStream();
-    });
-  }
-  async patch(url, options) {
-    return this.request("PATCH", url, options);
-  }
-  async patchText(url, options) {
-    const response = await this.request("PATCH", url, { ...options });
-    return response.body.readAsText();
-  }
-  async patchJson(url, options) {
-    const response = await this.request("PATCH", url, { ...options });
-    return response.body.readAsJson();
-  }
-  async patchBuffer(url, options) {
-    const response = await this.request("PATCH", url, { ...options });
-    return response.body.readAsBuffer();
-  }
-  patchStream(url, options) {
-    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const response = await this.request("PATCH", url, { ...options });
-      return response.body.readAsBinaryStream();
-    });
-  }
-  async delete(url, options) {
-    return this.request("DELETE", url, options);
-  }
-  async deleteText(url, options) {
-    const response = await this.request("DELETE", url, { ...options });
-    return response.body.readAsText();
-  }
-  async deleteJson(url, options) {
-    const response = await this.request("DELETE", url, { ...options });
-    return response.body.readAsJson();
-  }
-  async deleteBuffer(url, options) {
-    const response = await this.request("DELETE", url, { ...options });
-    return response.body.readAsBuffer();
-  }
-  deleteStream(url, options) {
-    return (0, import_readable_stream_from_promise.readableStreamFromPromise)(async () => {
-      const response = await this.request("DELETE", url, { ...options });
-      return response.body.readAsBinaryStream();
-    });
-  }
-  async request(method, url, options = {}) {
-    const request = new import_http_client_request.HttpClientRequest(url, method, options);
-    return this.rawRequest(request);
-  }
-  async rawRequest(request) {
-    const preparedRequest = this.prepareRequest(request);
-    return this.callHandler(preparedRequest, request.context);
-  }
-  updateHandlers() {
-    this.callHandler = (0, import_middleware.composeAsyncMiddleware)([...this.middleware, ...this.internalMiddleware], async (request) => this.adapter.call(request), { allowMultipleNextCalls: true });
-  }
-  prepareRequest(request) {
-    const clone = request.clone();
-    clone.headers = new import_http_headers.HttpHeaders(this.headers);
-    clone.headers.setMany(request.headers);
-    return clone;
-  }
+import { hasErrorHandler, isErrorResponse, parseErrorResponse } from '../../api/response.js';
+import { injectArg, optional, singleton } from '../../container/index.js';
+import { toArray } from '../../utils/array/array.js';
+import { encodeBase64 } from '../../utils/base64.js';
+import { encodeUtf8 } from '../../utils/encoding.js';
+import { composeAsyncMiddleware } from '../../utils/middleware.js';
+import { objectEntries } from '../../utils/object/object.js';
+import { readableStreamFromPromise } from '../../utils/stream/readable-stream-from-promise.js';
+import { isDefined, isObject, isUndefined } from '../../utils/type-guards.js';
+import { buildUrl } from '../../utils/url-builder.js';
+import { HttpHeaders } from '../http-headers.js';
+import { HttpError, HttpErrorReason } from '../http.error.js';
+import { normalizeHttpValue, normalizeSingleHttpValue } from '../types.js';
+import { HttpClientOptions } from './http-client-options.js';
+import { HttpClientRequest } from './http-client-request.js';
+import { HttpClientAdapter } from './http-client.adapter.js';
+export let HttpClient = class HttpClient {
+    adapter;
+    headers;
+    middleware;
+    internalMiddleware;
+    callHandler;
+    options;
+    constructor(adapter, options = {}) {
+        this.adapter = adapter;
+        this.options = options;
+        this.middleware = [...(options.middleware ?? [])];
+        this.headers = new HttpHeaders();
+        this.internalMiddleware = [
+            getBuildRequestUrlMiddleware(options.baseUrl),
+            addRequestHeadersMiddleware,
+            ...((options.enableErrorHandling ?? true) ? [errorMiddleware] : [])
+        ];
+        this.updateHandlers();
+    }
+    addMiddleware(middleware) {
+        this.middleware.push(middleware);
+        this.updateHandlers();
+    }
+    setDefaultHeader(name, value) {
+        this.headers.set(name, value);
+    }
+    deleteDefaultHeader(name) {
+        this.headers.remove(name);
+    }
+    async head(url, options) {
+        return this.request('HEAD', url, { ...options });
+    }
+    async get(url, options) {
+        return this.request('GET', url, options);
+    }
+    async getText(url, options) {
+        const response = await this.request('GET', url, { ...options });
+        return response.body.readAsText();
+    }
+    async getJson(url, options) {
+        const response = await this.request('GET', url, { ...options });
+        return response.body.readAsJson();
+    }
+    async getBuffer(url, options) {
+        const response = await this.request('GET', url, { ...options });
+        return response.body.readAsBuffer();
+    }
+    getStream(url, options) {
+        return readableStreamFromPromise(async () => {
+            const response = await this.request('GET', url, { ...options });
+            return response.body.readAsStream();
+        });
+    }
+    getTextStream(url, options) {
+        return readableStreamFromPromise(async () => {
+            const response = await this.request('GET', url, { ...options });
+            return response.body.readAsTextStream();
+        });
+    }
+    getBinaryStream(url, options) {
+        return readableStreamFromPromise(async () => {
+            const response = await this.request('GET', url, { ...options });
+            return response.body.readAsBinaryStream();
+        });
+    }
+    async post(url, options) {
+        return this.request('POST', url, options);
+    }
+    async postText(url, options) {
+        const response = await this.request('POST', url, { ...options });
+        return response.body.readAsText();
+    }
+    async postJson(url, options) {
+        const response = await this.request('POST', url, { ...options });
+        return response.body.readAsJson();
+    }
+    async postBuffer(url, options) {
+        const response = await this.request('POST', url, { ...options });
+        return response.body.readAsBuffer();
+    }
+    postStream(url, options) {
+        return readableStreamFromPromise(async () => {
+            const response = await this.request('POST', url, { ...options });
+            return response.body.readAsBinaryStream();
+        });
+    }
+    async put(url, options) {
+        return this.request('PUT', url, options);
+    }
+    async putText(url, options) {
+        const response = await this.request('PUT', url, { ...options });
+        return response.body.readAsText();
+    }
+    async putJson(url, options) {
+        const response = await this.request('PUT', url, { ...options });
+        return response.body.readAsJson();
+    }
+    async putBuffer(url, options) {
+        const response = await this.request('PUT', url, { ...options });
+        return response.body.readAsBuffer();
+    }
+    putStream(url, options) {
+        return readableStreamFromPromise(async () => {
+            const response = await this.request('PUT', url, { ...options });
+            return response.body.readAsBinaryStream();
+        });
+    }
+    async patch(url, options) {
+        return this.request('PATCH', url, options);
+    }
+    async patchText(url, options) {
+        const response = await this.request('PATCH', url, { ...options });
+        return response.body.readAsText();
+    }
+    async patchJson(url, options) {
+        const response = await this.request('PATCH', url, { ...options });
+        return response.body.readAsJson();
+    }
+    async patchBuffer(url, options) {
+        const response = await this.request('PATCH', url, { ...options });
+        return response.body.readAsBuffer();
+    }
+    patchStream(url, options) {
+        return readableStreamFromPromise(async () => {
+            const response = await this.request('PATCH', url, { ...options });
+            return response.body.readAsBinaryStream();
+        });
+    }
+    async delete(url, options) {
+        return this.request('DELETE', url, options);
+    }
+    async deleteText(url, options) {
+        const response = await this.request('DELETE', url, { ...options });
+        return response.body.readAsText();
+    }
+    async deleteJson(url, options) {
+        const response = await this.request('DELETE', url, { ...options });
+        return response.body.readAsJson();
+    }
+    async deleteBuffer(url, options) {
+        const response = await this.request('DELETE', url, { ...options });
+        return response.body.readAsBuffer();
+    }
+    deleteStream(url, options) {
+        return readableStreamFromPromise(async () => {
+            const response = await this.request('DELETE', url, { ...options });
+            return response.body.readAsBinaryStream();
+        });
+    }
+    async request(method, url, options = {}) {
+        const request = new HttpClientRequest(url, method, options);
+        return this.rawRequest(request);
+    }
+    async rawRequest(request) {
+        const preparedRequest = this.prepareRequest(request);
+        return this.callHandler(preparedRequest, request.context);
+    }
+    updateHandlers() {
+        this.callHandler = composeAsyncMiddleware([...this.middleware, ...this.internalMiddleware], async (request) => this.adapter.call(request), { allowMultipleNextCalls: true });
+    }
+    prepareRequest(request) {
+        const clone = request.clone();
+        clone.headers = new HttpHeaders(this.headers);
+        clone.headers.setMany(request.headers);
+        return clone;
+    }
 };
 HttpClient = __decorate([
-  (0, import_container.singleton)(),
-  __param(1, (0, import_container.optional)()),
-  __param(1, (0, import_container.injectArg)()),
-  __metadata("design:paramtypes", [import_http_client_adapter.HttpClientAdapter, import_http_client_options.HttpClientOptions])
+    singleton(),
+    __param(1, optional()),
+    __param(1, injectArg()),
+    __metadata("design:paramtypes", [HttpClientAdapter, HttpClientOptions])
 ], HttpClient);
 function getBuildRequestUrlMiddleware(baseUrl) {
-  async function buildUrlParametersMiddleware(request, next) {
-    if (!request.mapParameters) {
-      return next(request);
-    }
-    const modifiedRequest = mapParameters(request, baseUrl);
-    return next(modifiedRequest);
-  }
-  return buildUrlParametersMiddleware;
+    async function buildUrlParametersMiddleware(request, next) {
+        if (!request.mapParameters) {
+            return next(request);
+        }
+        const modifiedRequest = mapParameters(request, baseUrl);
+        return next(modifiedRequest);
+    }
+    return buildUrlParametersMiddleware;
 }
 async function addRequestHeadersMiddleware(request, next) {
-  const clone = request.clone();
-  const { body, authorization } = clone;
-  if ((0, import_type_guards.isDefined)(body) && (0, import_type_guards.isUndefined)(clone.headers.contentType)) {
-    if ((0, import_type_guards.isDefined)(body.json)) {
-      clone.headers.contentType = "application/json";
-    } else if ((0, import_type_guards.isDefined)(body.text)) {
-      clone.headers.contentType = "text/plain";
-    } else if ((0, import_type_guards.isDefined)(body.form)) {
-      clone.headers.contentType = "application/x-www-form-urlencoded";
-    } else if ((0, import_type_guards.isDefined)(body.blob)) {
-      clone.headers.contentType = body.blob.type.length > 0 ? body.blob.type : "application/octet-stream";
-    } else if ((0, import_type_guards.isDefined)(body.stream) || (0, import_type_guards.isDefined)(body.buffer)) {
-      clone.headers.contentType = "application/octet-stream";
-    }
-  }
-  if ((0, import_type_guards.isDefined)(authorization) && (0, import_type_guards.isUndefined)(clone.headers.authorization)) {
-    if ((0, import_type_guards.isDefined)(authorization.basic)) {
-      const base64 = (0, import_base64.encodeBase64)((0, import_encoding.encodeUtf8)(`${authorization.basic.username}:${authorization.basic.password}`));
-      clone.headers.authorization = `Basic ${base64}`;
-    } else if ((0, import_type_guards.isDefined)(authorization.bearer)) {
-      clone.headers.authorization = `Bearer ${authorization.bearer}`;
-    } else if ((0, import_type_guards.isDefined)(authorization.token)) {
-      clone.headers.authorization = `Token ${authorization.token}`;
-    }
-  }
-  return next(clone);
+    const clone = request.clone();
+    const { body, authorization } = clone;
+    if (isDefined(body) && isUndefined(clone.headers.contentType)) {
+        if (isDefined(body.json)) {
+            clone.headers.contentType = 'application/json';
+        }
+        else if (isDefined(body.text)) {
+            clone.headers.contentType = 'text/plain';
+        }
+        else if (isDefined(body.form)) {
+            clone.headers.contentType = 'application/x-www-form-urlencoded';
+        }
+        else if (isDefined(body.blob)) {
+            clone.headers.contentType = (body.blob.type.length > 0) ? body.blob.type : 'application/octet-stream';
+        }
+        else if (isDefined(body.stream) || isDefined(body.buffer)) {
+            clone.headers.contentType = 'application/octet-stream';
+        }
+    }
+    if (isDefined(authorization) && isUndefined(clone.headers.authorization)) {
+        if (isDefined(authorization.basic)) {
+            const base64 = encodeBase64(encodeUtf8(`${authorization.basic.username}:${authorization.basic.password}`));
+            clone.headers.authorization = `Basic ${base64}`;
+        }
+        else if (isDefined(authorization.bearer)) {
+            clone.headers.authorization = `Bearer ${authorization.bearer}`;
+        }
+        else if (isDefined(authorization.token)) {
+            clone.headers.authorization = `Token ${authorization.token}`;
+        }
+    }
+    return next(clone);
 }
 async function errorMiddleware(request, next) {
-  try {
-    const response = await next(request);
-    if (request.throwOnNon200 && (response.statusCode < 200 || response.statusCode >= 400)) {
-      const httpError = await import_http_error.HttpError.create(import_http_error.HttpErrorReason.Non200StatusCode, request, response, `Status code ${response.statusCode}.`);
-      throw httpError;
-    }
-    return response;
-  } catch (error) {
-    if (!(error instanceof import_http_error.HttpError) || error.responseInstance?.headers.contentType?.includes("json") == false) {
-      throw error;
-    }
-    if ((0, import_type_guards.isDefined)(error.responseBody)) {
-      if (!(0, import_response.isErrorResponse)(error.responseBody) || !(0, import_response.hasErrorHandler)(error.responseBody)) {
+    try {
+        const response = await next(request);
+        if (request.throwOnNon200 && ((response.statusCode < 200) || (response.statusCode >= 400))) {
+            const httpError = await HttpError.create(HttpErrorReason.Non200StatusCode, request, response, `Status code ${response.statusCode}.`);
+            throw httpError;
+        }
+        return response;
+    }
+    catch (error) {
+        if (!(error instanceof HttpError) || (error.responseInstance?.headers.contentType?.includes('json') == false)) {
+            throw error;
+        }
+        if (isDefined(error.responseBody)) {
+            if (!isErrorResponse(error.responseBody) || !hasErrorHandler(error.responseBody)) {
+                throw error;
+            }
+            const parsedError = parseErrorResponse(error.responseBody, false);
+            if (isDefined(parsedError)) {
+                throw parsedError;
+            }
+        }
         throw error;
-      }
-      const parsedError = (0, import_response.parseErrorResponse)(error.responseBody, false);
-      if ((0, import_type_guards.isDefined)(parsedError)) {
-        throw parsedError;
-      }
-    }
-    throw error;
-  }
+    }
 }
+// eslint-disable-next-line max-statements, max-lines-per-function, complexity
 function mapParameters(request, baseUrl) {
-  const clone = request.clone();
-  const isGetOrHead = request.method == "GET" || request.method == "HEAD";
-  let url;
-  const filteredParameterEntries = (0, import_object.objectEntries)(request.parameters ?? {}).filter(([_, value]) => (0, import_type_guards.isDefined)(value));
-  const filteredParameters = Object.fromEntries(filteredParameterEntries);
-  let parameterEntries = new Set(filteredParameterEntries);
-  if (!request.mapParametersToUrl) {
-    url = new URL(request.url, baseUrl);
-  } else {
-    const { parsedUrl, parametersRest } = (0, import_url_builder.buildUrl)(request.url, filteredParameters, { arraySeparator: request.urlParametersSeparator });
-    url = new URL(parsedUrl, baseUrl);
-    parameterEntries = new Set((0, import_object.objectEntries)(parametersRest));
-  }
-  if (request.mapParametersToBody && !isGetOrHead && (0, import_type_guards.isUndefined)(request.body)) {
-    clone.body = { json: Object.fromEntries(parameterEntries) };
-    parameterEntries.clear();
-  }
-  if (request.mapParametersToQuery) {
-    for (const entry of parameterEntries) {
-      const [parameter, value] = entry;
-      if ((0, import_type_guards.isUndefined)(value) || (0, import_type_guards.isObject)(value)) {
-        continue;
-      }
-      for (const val of (0, import_array.toArray)(value)) {
-        url.searchParams.append(parameter, (0, import_types.normalizeSingleHttpValue)(val));
-      }
-      parameterEntries.delete(entry);
-    }
-  }
-  if (parameterEntries.size > 0) {
-    throw new import_http_error.HttpError(import_http_error.HttpErrorReason.InvalidRequest, request, void 0, "Not all parameters could be mapped to url, query and body because request is either GET/HEAD or body is already defined");
-  }
-  if ((0, import_type_guards.isDefined)(request.query)) {
-    for (const [key, valueOrValues] of request.query) {
-      const normalizedValues = (0, import_types.normalizeHttpValue)(valueOrValues);
-      if ((0, import_type_guards.isDefined)(normalizedValues)) {
-        for (const normalizedValue of (0, import_array.toArray)(normalizedValues)) {
-          url.searchParams.append(key, normalizedValue.toString());
+    const clone = request.clone();
+    const isGetOrHead = (request.method == 'GET') || (request.method == 'HEAD');
+    let url;
+    const filteredParameterEntries = objectEntries(request.parameters ?? {}).filter(([_, value]) => isDefined(value));
+    const filteredParameters = Object.fromEntries(filteredParameterEntries);
+    let parameterEntries = new Set(filteredParameterEntries);
+    if (!request.mapParametersToUrl) {
+        url = new URL(request.url, baseUrl);
+    }
+    else {
+        const { parsedUrl, parametersRest } = buildUrl(request.url, filteredParameters, { arraySeparator: request.urlParametersSeparator });
+        url = new URL(parsedUrl, baseUrl);
+        parameterEntries = new Set(objectEntries(parametersRest));
+    }
+    if (request.mapParametersToBody && !isGetOrHead && isUndefined(request.body)) {
+        clone.body = { json: Object.fromEntries(parameterEntries) };
+        parameterEntries.clear();
+    }
+    if (request.mapParametersToQuery) {
+        for (const entry of parameterEntries) {
+            const [parameter, value] = entry;
+            if (isUndefined(value) || isObject(value)) {
+                continue;
+            }
+            for (const val of toArray(value)) {
+                url.searchParams.append(parameter, normalizeSingleHttpValue(val));
+            }
+            parameterEntries.delete(entry);
         }
-      }
     }
-  }
-  clone.url = url.href;
-  return clone;
+    if (parameterEntries.size > 0) {
+        throw new HttpError(HttpErrorReason.InvalidRequest, request, undefined, 'Not all parameters could be mapped to url, query and body because request is either GET/HEAD or body is already defined');
+    }
+    if (isDefined(request.query)) {
+        for (const [key, valueOrValues] of request.query) {
+            const normalizedValues = normalizeHttpValue(valueOrValues);
+            if (isDefined(normalizedValues)) {
+                for (const normalizedValue of toArray(normalizedValues)) {
+                    url.searchParams.append(key, normalizedValue.toString());
+                }
+            }
+        }
+    }
+    clone.url = url.href;
+    return clone;
 }