@sap/cds 6.1.3 → 6.2.1

package/lib/srv/protocols/odata-v2-proxy.js

@@ -0,0 +1,3767 @@
+"use strict";
+
+// OData V2/V4 Delta: http://docs.oasis-open.org/odata/new-in-odata/v4.0/cn01/new-in-odata-v4.0-cn01.html
+
+const URL = require("url");
+const express = require("express"); // eslint-disable-line cds/no-missing-dependencies
+const expressFileUpload = require("express-fileupload"); // eslint-disable-line cds/no-missing-dependencies
+const fetch = require("node-fetch"); // eslint-disable-line cds/no-missing-dependencies
+const cds = require("../../index"); // eslint-disable-line cds/no-missing-dependencies
+const { promisify } = require("util");
+const { createProxyMiddleware } = require("http-proxy-middleware"); // eslint-disable-line cds/no-missing-dependencies
+
+const LOG = cds.log("cov2ap");
+
+const SeverityMap = {
+  1: "success",
+  2: "info",
+  3: "warning",
+  4: "error",
+};
+
+// NOTE: we want to support HANA's SYSUUID, which does not conform to real UUID formats
+const UUIDLikeRegex = /guid'([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})'/gi;
+// https://www.w3.org/TR/xmlschema11-2/#nt-duDTFrag
+const DurationRegex =
+  /^P(?:(\d)Y)?(?:(\d{1,2})M)?(?:(\d{1,2})D)?T(?:(\d{1,2})H)?(?:(\d{2})M)?(?:(\d{2}(?:\.\d+)?)S)?$/i;
+// Unsupported Draft Filter
+const UnsupportedDraftFilterRegex =
+  /\(IsActiveEntity eq true and (.*?)\) or \(IsActiveEntity eq false and \((.*?) or HasActiveEntity eq false\)\)/;
+
+// https://cap.cloud.sap/docs/cds/types
+const DataTypeMap = {
+  "cds.UUID": { v2: `guid'$1'`, v4: UUIDLikeRegex },
+  // "cds.Boolean" - no transformation
+  // "cds.Integer" - no transformation
+  "cds.Integer64": { v2: `$1L`, v4: /([-]?[0-9]+?)L/gi },
+  "cds.Decimal": { v2: `$1m`, v4: /([-]?[0-9]+?\.?[0-9]*)m/gi },
+  "cds.DecimalFloat": { v2: `$1f`, v4: /([-]?[0-9]+?\.?[0-9]*)f/gi },
+  "cds.Double": { v2: `$1d`, v4: /([-]?[0-9]+?\.?[0-9]*(?:E[+-]?[0-9]+?)?)d/gi },
+  "cds.Date": { v2: `datetime'$1'`, v4: /datetime'(.+?)'/gi },
+  "cds.Time": { v2: `time'$1'`, v4: /time'(.+?)'/gi },
+  "cds.DateTime": { v2: `datetimeoffset'$1'`, v4: /datetime(?:offset)?'(.+?)'/gi },
+  "cds.Timestamp": { v2: `datetimeoffset'$1'`, v4: /datetime(?:offset)?'(.+?)'/gi },
+  "cds.String": { v2: `'$1'`, v4: /(.*)/gis },
+  "cds.Binary": { v2: `binary'$1'`, v4: /X'(?:[0-9a-f][0-9a-f])+?'/gi },
+  "cds.LargeBinary": { v2: `binary'$1'`, v4: /X'(?:[0-9a-f][0-9a-f])+?'/gi },
+  "cds.LargeString": { v2: `'$1'`, v4: /(.*)/gis },
+};
+
+// https://www.odata.org/documentation/odata-version-2-0/overview/ (6. Primitive Data Types)
+// https://cap.cloud.sap/docs/advanced/odata#type-mapping
+const DataTypeOData = {
+  Binary: "cds.Binary",
+  Boolean: "cds.Boolean",
+  Byte: "cds.Integer",
+  DateTime: "cds.DateTime",
+  Decimal: "cds.Decimal",
+  Double: "cds.Double",
+  Single: "cds.Double",
+  Guid: "cds.UUID",
+  Int16: "cds.Integer",
+  Int32: "cds.Integer",
+  Int64: "cds.Integer64",
+  SByte: "cds.Integer",
+  String: "cds.String",
+  Time: "cds.Time",
+  DateTimeOffset: "cds.Timestamp",
+  Date: "cds.Date",
+  TimeOfDay: "cds.Time",
+  _Decimal: "cds.DecimalFloat",
+  _Binary: "cds.LargeBinary",
+  _String: "cds.LargeString",
+};
+
+const AggregationMap = {
+  SUM: "sum",
+  MIN: "min",
+  MAX: "max",
+  AVG: "average",
+  COUNT: "countdistinct",
+  COUNT_DISTINCT: "countdistinct",
+  $COUNT: "$count",
+  NONE: "none",
+  NOP: "nop",
+};
+
+const DefaultAggregation = AggregationMap.SUM;
+
+const FilterFunctions = {
+  "substringof($,$)": "contains($2,$1)",
+  "gettotaloffsetminutes($)": "totaloffsetminutes($1)",
+};
+
+const FilterFunctionsCaseInsensitive = {
+  "substringof($,$)": "contains(tolower($2),tolower($1))",
+  "startswith($,$)": "startswith(tolower($1),tolower($2))",
+  "endswith($,$)": "endswith(tolower($1),tolower($2))",
+};
+
+const ProcessingDirection = {
+  Request: "req",
+  Response: "res",
+};
+
+const DefaultHost = "localhost";
+const DefaultPort = 4004;
+const DefaultTenant = "00000000-0000-0000-0000-000000000000";
+const AggregationPrefix = "__AGGREGATION__";
+const IEEE754Compatible = "IEEE754Compatible=true";
+
+function convertToNodeHeaders(webHeaders) {
+  return Array.from(webHeaders.entries()).reduce((result, [key, value]) => {
+    result[key] = value;
+    return result;
+  }, {});
+}
+
+/**
+ * Instantiates a CDS OData V2 Adapter Proxy Express Router for a CDS-based OData V4 Server:
+ * @param {object} options CDS OData V2 Adapter Proxy options object.
+ * @param {string} options.base Base path under which the service is reachable. Default is ''.
+ * @param {string} options.path Path under which the proxy is reachable. Default is 'v2'.
+ * @param {string|string[]|object} options.model CDS service model (path(s) or CSN). Default is 'all'.
+ * @param {number} options.port Target port which points to OData V4 backend port. Default is process.env.PORT or 4004.
+ * @param {string} options.target Target which points to OData V4 backend host:port. Use 'auto' to infer the target from server url after listening. Default is e.g. 'http://localhost:4004'.
+ * @param {string} options.targetPath Target path to which is redirected. Default is ''.
+ * @param {object} options.services Service mapping object from url path name to service name. Default is {}.
+ * @param {boolean} options.mtxRemote CDS model is retrieved remotely via MTX endpoint for multitenant scenario (old MTX only). Default is false.
+ * @param {string} options.mtxEndpoint Endpoint to retrieve MTX metadata when option 'mtxRemote' is active (old MTX only). Default is '/mtx/v1'.
+ * @param {boolean} options.ieee754Compatible Edm.Decimal and Edm.Int64 are serialized IEEE754 compatible. Default is true.
+ * @param {number} options.fileUploadSizeLimit File upload file size limit (in bytes). Default is 10485760 (10 MB).
+ * @param {boolean} options.continueOnError Indicates to OData V4 backend to continue on error. Default is false.
+ * @param {boolean} options.isoTime Use ISO 8601 format for type cds.Time (Edm.Time). Default is false.
+ * @param {boolean} options.isoDate Use ISO 8601 format for type cds.Date (Edm.DateTime). Default is false.
+ * @param {boolean} options.isoDateTime Use ISO 8601 format for type cds.DateTime (Edm.DateTimeOffset). Default is false.
+ * @param {boolean} options.isoTimestamp Use ISO 8601 format for type cds.Timestamp (Edm.DateTimeOffset). Default is false.
+ * @param {boolean} options.isoDateTimeOffset Use ISO 8601 format for type Edm.DateTimeOffset (cds.DateTime, cds.Timestamp). Default is false.
+ * @param {string} options.bodyParserLimit Request and response body parser size limit. Default is '100mb'.
+ * @param {boolean} options.returnCollectionNested Collection of entity type is returned nested into a results section. Default is true.
+ * @param {boolean} options.returnComplexNested Function import return structure of complex type (non collection) is nested using function import name. Default is true.
+ * @param {boolean} options.returnPrimitiveNested Function import return structure of primitive type (non collection) is nested using function import name. Default is true.
+ * @param {boolean} options.returnPrimitivePlain Function import return value of primitive type is rendered as plain JSON value. Default is true.
+ * @param {string} options.messageTargetDefault Specifies the message target default, if target is undefined. Default is '/#TRANSIENT#'.
+ * @param {boolean} options.caseInsensitive: Transforms search functions i.e. substringof, startswith, endswith to case-insensitive variant. Default is false.
+ * @param {boolean} options.propagateMessageToDetails: Propagates root error or message always to details section. Default is false.
+ * @param {boolean} options.contentDisposition: Default content disposition for media streams (inline, attachment), if not available or calculated. Default is 'attachment'.
+ * @param {boolean} options.calcContentDisposition: Calculate content disposition for media streams even if already available. Default is false.
+ * @param {boolean} options.quoteSearch: Specifies if search expression is quoted automatically. Default is true.
+ * @param {boolean} options.fixDraftRequests: Specifies if unsupported draft requests are converted to a working version. Default is false.
+ * @returns {express.Router} CDS OData V2 Adapter Proxy Express Router
+ */
+function cov2ap(options = {}) {
+  const optionWithFallback = (name, fallback) => {
+    if (options && Object.prototype.hasOwnProperty.call(options, name)) {
+      return options[name];
+    }
+    if (cds.env.cov2ap && Object.prototype.hasOwnProperty.call(cds.env.cov2ap, name)) {
+      return cds.env.cov2ap[name];
+    }
+    return fallback;
+  };
+
+  const proxyCache = {};
+  const router = express.Router();
+  const base = optionWithFallback("base", "");
+  const _with_leading_slash = s => s.replace(/^([^/])/,'/$1')
+  const path = _with_leading_slash(optionWithFallback("path", "/v2"))
+  const sourcePath = _with_leading_slash(optionWithFallback("sourcePath", `${base ? "/" + base : ""}/${path}`))
+  const targetPath = _with_leading_slash(optionWithFallback("targetPath", ""))
+  const pathRewrite = { [`^${sourcePath}`]: targetPath };
+  let port = optionWithFallback("port", process.env.PORT || DefaultPort);
+  let target = optionWithFallback("target", `http://${DefaultHost}:${port}`);
+  const logLevel = optionWithFallback("logLevel", 'info');
+  const services = optionWithFallback("services", {});
+  const mtxRemote = optionWithFallback("mtxRemote", false);
+  const mtxEndpoint = optionWithFallback("mtxEndpoint", "/mtx/v1");
+  const ieee754Compatible = optionWithFallback("ieee754Compatible", true);
+  const fileUploadSizeLimit = optionWithFallback("fileUploadSizeLimit", 10 * 1024 * 1024);
+  const continueOnError = optionWithFallback("continueOnError", false);
+  const isoTime = optionWithFallback("isoTime", false);
+  const isoDate = optionWithFallback("isoDate", false);
+  const isoDateTime = optionWithFallback("isoDateTime", false);
+  const isoTimestamp = optionWithFallback("isoTimestamp", false);
+  const isoDateTimeOffset = optionWithFallback("isoDateTimeOffset", false);
+  const bodyParserLimit = optionWithFallback("bodyParserLimit", "100mb");
+  const returnCollectionNested = optionWithFallback("returnCollectionNested", true);
+  const returnComplexNested = optionWithFallback("returnComplexNested", true);
+  const returnPrimitiveNested = optionWithFallback("returnPrimitiveNested", true);
+  const returnPrimitivePlain = optionWithFallback("returnPrimitivePlain", true);
+  const messageTargetDefault = optionWithFallback("messageTargetDefault", "/#TRANSIENT#");
+  const caseInsensitive = optionWithFallback("caseInsensitive", false);
+  const propagateMessageToDetails = optionWithFallback("propagateMessageToDetails", false);
+  const contentDisposition = optionWithFallback("contentDisposition", "attachment");
+  const calcContentDisposition = optionWithFallback("calcContentDisposition", false);
+  const quoteSearch = optionWithFallback("quoteSearch", true);
+  const fixDraftRequests = optionWithFallback("fixDraftRequests", false);
+
+  if (caseInsensitive) {
+    Object.assign(FilterFunctions, FilterFunctionsCaseInsensitive);
+  }
+
+  const fileUpload = expressFileUpload({
+    abortOnLimit: true,
+    limits: {
+      files: 1,
+      fileSize: fileUploadSizeLimit,
+    },
+  });
+
+  let model = optionWithFallback("model", "all");
+  if (Array.isArray(model)) {
+    model = model.map((entry) => (entry === "all" ? "*" : entry));
+  } else {
+    model = model === "all" ? "*" : model;
+  }
+  model = cds.resolve(model);
+
+  cds.on("serving", (service) => {
+    const isOData = Object.keys(service._adapters).find((adapter) => adapter.startsWith("odata"));
+    if (!isOData) {
+      return;
+    }
+    const provider = (entity) => {
+      const href = `${sourcePath}${service.path}/${entity || "$metadata"}`;
+      return { href, name: `${entity || "$metadata"} (V2)`, title: "OData V2" };
+    };
+    service.$linkProviders = service.$linkProviders || [];
+    service.$linkProviders.push(provider);
+  });
+
+  if (cds.mtx && cds.mtx.eventEmitter && cds.env.requires && cds.env.requires.multitenancy) {
+    cds.mtx.eventEmitter.on(cds.mtx.events.TENANT_UPDATED, (tenant) => {
+      delete proxyCache[tenant];
+    });
+  }
+  // TODO: Cache invalidation for Streamlined MTX (when extensibility is supported)
+
+  router.use(`${path}/:service`, async (req, res, next) => {
+    req.contextId =
+      req.headers["x-correlation-id"] ||
+      req.headers["x-correlationid"] ||
+      req.headers["x-request-id"] ||
+      req.headers["x-vcap-request-id"] ||
+      cds.utils.uuid();
+    res.set("x-request-id", req.contextId);
+    res.set("x-correlation-id", req.contextId);
+    res.set("x-correlationid", req.contextId);
+    try {
+      const [authType, token] = (req.headers.authorization && req.headers.authorization.split(" ")) || [];
+      if (authType && token) {
+        let jwtBody;
+        switch (authType) {
+          case "Basic":
+            req.user = {
+              id: decodeBase64(token).split(":")[0],
+            };
+            if (req.user.id && cds.env.requires.auth && cds.env.requires.auth.strategy === "mock") {
+              const user = (cds.env.requires.auth.users || {})[req.user.id];
+              req.tenant = user && (user.tenant || (user.jwt && user.jwt.zid));
+            }
+            break;
+          case "Bearer":
+            jwtBody = decodeJwtTokenBody(token);
+            req.user = {
+              id: jwtBody.user_name || jwtBody.client_id,
+            };
+            req.tenant = jwtBody.zid;
+            break;
+        }
+      }
+    } catch (err) {
+      logError(req, "Authorization", err);
+    }
+    next();
+  });
+
+  router.get(`${path}/*\\$metadata`, async (req, res) => {
+    let serviceValid = true;
+    try {
+      const metadataUrlPath = targetUrl(req);
+
+      // Trace
+      traceRequest(req, "Request", req.method, req.originalUrl, req.headers, req.body);
+      traceRequest(req, "ProxyRequest", req.method, metadataUrlPath, req.headers, req.body);
+
+      const result = await Promise.all([
+        fetch(target + metadataUrlPath, {
+          method: "GET",
+          headers: propagateHeaders(req),
+        }),
+        (async () => {
+          const { csn } = await getMetadata(req);
+          req.csn = csn;
+          const service = serviceFromRequest(req);
+          if (service && service.name) {
+            serviceValid = service.valid;
+            const { edmx } = await getMetadata(req, service.name);
+            return edmx;
+          }
+        })(),
+      ]);
+      const [metadataResponse, edmx] = result;
+      const headers = convertBasicHeaders(convertToNodeHeaders(metadataResponse.headers));
+      delete headers["content-encoding"];
+      const metadataBody = await metadataResponse.text();
+      let body;
+      if (metadataResponse.ok) {
+        body = edmx;
+      } else {
+        body = metadataBody;
+      }
+      setContentLength(headers, body);
+
+      // Trace
+      traceResponse(
+        req,
+        "Proxy Response",
+        metadataResponse.status,
+        metadataResponse.statusMessage,
+        headers,
+        metadataBody
+      );
+
+      respond(req, res, metadataResponse.status, headers, body);
+    } catch (err) {
+      if (serviceValid) {
+        // Error
+        logError(req, "MetadataRequest", err);
+        res.status(500).send("Internal Server Error");
+      } else {
+        res.status(404).send("Not Found");
+      }
+    }
+  });
+
+  router.use(`${path}/:service`,
+
+    // Body Parsers
+    (req, res, next) => {
+      const contentType = req.header("content-type");
+      if (!contentType) {
+        return next();
+      }
+
+      if (isApplicationJSON(contentType)) {
+        express.json({ limit: bodyParserLimit })(req, res, next);
+      } else if (isMultipartMixed(contentType)) {
+        express.text({ type: "multipart/mixed", limit: bodyParserLimit })(req, res, next);
+      } else {
+        req.checkUploadBinary = req.method === "POST";
+        next();
+      }
+    },
+
+    // Inject Context
+    async (req, res, next) => {
+      try {
+        const { csn } = await getMetadata(req);
+        req.csn = csn;
+      } catch (err) {
+        // Error
+        logError(req, "Request", err);
+        res.status(500).send("Internal Server Error");
+        return;
+      }
+      const service = serviceFromRequest(req);
+      req.base = base;
+      req.service = service.name;
+      req.servicePath = service.path;
+      req.context = {};
+      req.contexts = [];
+      req.contentId = {};
+      req.lookupContext = {};
+      next();
+    },
+
+    // File Upload
+    async (req, res, next) => {
+      if (!req.checkUploadBinary) {
+        return next();
+      }
+
+      const targetPath = targetUrl(req);
+      const url = parseUrl(targetPath, req);
+      const definition = contextFromUrl(url, req);
+      if (!definition) {
+        return next();
+      }
+      const elements = definitionElements(definition);
+      const mediaDataElementName =
+        findElementByAnnotation(elements, "@Core.MediaType") ||
+        findElementByType(elements, DataTypeOData._Binary, req) ||
+        findElementByType(elements, DataTypeOData.Binary, req);
+      if (!mediaDataElementName) {
+        return next();
+      }
+
+      const handleMediaEntity = async (contentType, filename, headers = {}) => {
+        try {
+          contentType = contentType || "application/octet-stream";
+          const body = {};
+          // Custom body
+          const caseInsensitiveElements = structureKeys(elements).reduce((result, name) => {
+            result[name.toLowerCase()] = elements[name];
+            return result;
+          }, {});
+          Object.keys(headers).forEach((name) => {
+            const element = caseInsensitiveElements[name.toLowerCase()];
+            if (element) {
+              const value = convertDataTypeToV4(headers[name], elementType(element, req), definition, headers);
+              body[element.name] = decodeHeaderValue(definition, element, element.name, value);
+            }
+          });
+          const mediaDataElement = elements[mediaDataElementName];
+          const mediaTypeElementName =
+            (mediaDataElement["@Core.MediaType"] && mediaDataElement["@Core.MediaType"]["="]) ||
+            findElementByAnnotation(elements, "@Core.IsMediaType");
+          if (mediaTypeElementName) {
+            body[mediaTypeElementName] = contentType;
+          }
+          const contentDispositionFilenameElementName =
+            findElementValueByAnnotation(elements, "@Core.ContentDisposition.Filename") ||
+            findElementValueByAnnotation(elements, "@Common.ContentDisposition.Filename");
+          if (contentDispositionFilenameElementName && filename) {
+            const element = elements[contentDispositionFilenameElementName];
+            body[contentDispositionFilenameElementName] = decodeHeaderValue(
+              definition,
+              element,
+              element.name,
+              filename
+            );
+          }
+          const url = target + targetPath;
+          const postHeaders = propagateHeaders(req, {
+            ...headers,
+            "content-type": "application/json",
+          });
+          delete postHeaders["transfer-encoding"];
+
+          // Trace
+          traceRequest(req, "ProxyRequest", "POST", url, postHeaders, body);
+
+          const response = await fetch(url, {
+            method: "POST",
+            headers: postHeaders,
+            body: JSON.stringify(body),
+          });
+          const responseBody = await response.json();
+          const responseHeaders = convertToNodeHeaders(response.headers);
+          if (!response.ok) {
+            res
+              .status(response.status)
+              .set({
+                "content-type": "application/json",
+              })
+              .send(convertResponseError(responseBody, responseHeaders, definition, req));
+            return;
+          }
+
+          // Rewrite
+          req.method = "PUT";
+          req.originalUrl += `(${entityKey(responseBody, definition, elements, req)})/${mediaDataElementName}`;
+          req.baseUrl = req.originalUrl;
+          req.overwriteResponse = {
+            kind: "uploadBinary",
+            statusCode: response.status,
+            headers: responseHeaders,
+            body: responseBody,
+          };
+
+          // Trace
+          traceResponse(req, "ProxyResponse", response.status, response.statusText, responseHeaders, responseBody);
+
+          next();
+        } catch (err) {
+          // Error
+          logError(req, "FileUpload", err);
+          res.status(500).send("Internal Server Error");
+        }
+      };
+
+      const headers = req.headers;
+      if (isMultipartFormData(headers["content-type"])) {
+        fileUpload(req, res, async () => {
+          await handleMediaEntity(
+            req.body && req.body["content-type"],
+            req.body &&
+              (req.body["slug"] ||
+                req.body["filename"] ||
+                contentDispositionFilename(req.body) ||
+                contentDispositionFilename(headers) ||
+                req.body["name"]),
+            req.body
+          );
+        });
+      } else {
+        await handleMediaEntity(
+          headers["content-type"],
+          headers["slug"] || headers["filename"] || contentDispositionFilename(headers) || headers["name"],
+          headers
+        );
+      }
+    }
+  );
+
+  // Proxy Middleware
+  function setupProxyMiddleware() {
+    return createProxyMiddleware({
+      target,
+      changeOrigin: true,
+      selfHandleResponse: true,
+      logLevel,
+      pathRewrite,
+      onProxyReq: (proxyReq, req, res) => {
+        convertProxyRequest(proxyReq, req, res);
+      },
+      onProxyRes: (proxyRes, req, res) => {
+        convertProxyResponse(proxyRes, req, res);
+      },
+    });
+  }
+
+  if (target === "auto") {
+    cds.on("listening", ({ server, url }) => {
+      port = server.address().port;
+      target = url;
+      router.use(`${path}/*`, setupProxyMiddleware());
+    });
+  } else {
+    router.use(`${path}/*`, setupProxyMiddleware());
+  }
+
+  function contentDispositionFilename(headers) {
+    const contentDispositionHeader = headers["content-disposition"] || headers["Content-Disposition"];
+    if (contentDispositionHeader) {
+      const filenameMatch = contentDispositionHeader.match(/^.*filename="(.*)"$/is);
+      return filenameMatch && filenameMatch.pop();
+    }
+    return null;
+  }
+
+  function decodeHeaderValue(entity, element, name, value) {
+    if (value === undefined || value === null || value === "" || typeof value !== "string") {
+      return value;
+    }
+    let decodes = [];
+    if (Array.isArray(element["@cov2ap.headerDecode"])) {
+      decodes = element["@cov2ap.headerDecode"];
+    } else if (typeof element["@cov2ap.headerDecode"] === "string") {
+      decodes = [element["@cov2ap.headerDecode"]];
+    }
+    if (decodes.length > 0) {
+      decodes.forEach((decode) => {
+        switch (decode.toLowerCase()) {
+          case "uri":
+            value = decodeURI(value);
+            break;
+          case "uricomponent":
+            value = decodeURIComponent(value);
+            break;
+          case "base64":
+            value = decodeBase64(value);
+            break;
+        }
+      });
+    }
+    return value;
+  }
+
+  function serviceFromRequest(req) {
+    let serviceName;
+    let serviceValid = true;
+    let servicePath = req.params.service
+    let path = '/'+ servicePath
+    Object.keys(services).find((path) => {
+      if (servicePath.toLowerCase().startsWith(normalizeSlashes(path).toLowerCase())) {
+        serviceName = services[path];
+        servicePath = stripSlashes(path);
+        return true;
+      }
+      return false;
+    });
+    if (!serviceName) {
+      let srv = cds.service.providers.find(service => service.path === path)
+      if (srv) serviceName = srv.name
+    }
+    if (!serviceName) {
+      let srv = cds.service.providers.find(service => service.path === "/")
+      if (srv) servicePath = ""
+    }
+    if (!serviceName || !req.csn.definitions[serviceName] || req.csn.definitions[serviceName].kind !== "service") {
+      logWarning(req, "Service", "Service definition not found for request path", {
+        requestPath: servicePath,
+        serviceName,
+      });
+      serviceValid = false;
+    }
+    return {
+      name: serviceName,
+      path: servicePath,
+      valid: serviceValid,
+    };
+  }
+
+  async function getMetadata(req, service) {
+    let metadata;
+    if (req.tenant) {
+      if (mtxRemote && mtxEndpoint) {
+        metadata = await getTenantMetadataRemote(req, service);
+      } else if (cds.mtx && cds.env.requires && cds.env.requires.multitenancy) {
+        metadata = await getTenantMetadataLocal(req, service);
+      } else if (cds.env.requires && cds.env.requires["cds.xt.ModelProviderService"]) {
+        metadata = await getTenantMetadataStreamlined(req, service);
+      }
+    }
+    if (!metadata) {
+      metadata = await getDefaultMetadata(req, service);
+    }
+    return metadata;
+  }
+
+  async function getTenantMetadataRemote(req, service) {
+    const mtxBasePath =
+      mtxEndpoint.startsWith("http://") || mtxEndpoint.startsWith("https://") ? mtxEndpoint : `${target}${mtxEndpoint}`;
+    return await prepareMetadata(
+      req.tenant,
+      async (tenant) => {
+        const response = await fetch(`${mtxBasePath}/metadata/csn/${tenant}`, {
+          method: "GET",
+          headers: propagateHeaders(req),
+        });
+        if (!response.ok) {
+          throw new Error(await response.text());
+        }
+        return response.json();
+      },
+      async (tenant, service, locale) => {
+        const response = await fetch(
+          `${mtxBasePath}/metadata/edmx/${tenant}?name=${service}&language=${locale}&odataVersion=v2`,
+          {
+            method: "GET",
+            headers: propagateHeaders(req),
+          }
+        );
+        if (!response.ok) {
+          throw new Error(await response.text());
+        }
+        return response.text();
+      },
+      service,
+      determineLocale(req)
+    );
+  }
+
+  async function getTenantMetadataLocal(req, service) {
+    proxyCache[req.tenant] = proxyCache[req.tenant] || {};
+    const isExtended = await callCached(proxyCache[req.tenant], "isExtended", () => {
+      return cds.mtx.isExtended(req.tenant);
+    });
+    if (isExtended) {
+      return await prepareMetadata(
+        req.tenant,
+        async (tenant) => {
+          return await cds.mtx.getCsn(tenant);
+        },
+        async (tenant, service, locale) => {
+          return await cds.mtx.getEdmx(tenant, service, locale, "v2");
+        },
+        service,
+        determineLocale(req)
+      );
+    }
+  }
+
+  async function getTenantMetadataStreamlined(req, service) {
+    const { "cds.xt.ModelProviderService": mps } = cds.services;
+    proxyCache[req.tenant] = proxyCache[req.tenant] || {};
+    const isExtended = await callCached(proxyCache[req.tenant], "isExtended", () => {
+      return mps.isExtended(req.tenant);
+    });
+    if (isExtended) {
+      return await prepareMetadata(
+        req.tenant,
+        async (tenant) => {
+          return await mps.getCsn(tenant, ensureArray(req.features), "nodejs"); // TODO: getExtCsn()? (when extensibility is supported)
+        },
+        async (tenant, service, locale) => {
+          return await mps.getEdmx(tenant, ensureArray(req.features), service, locale, "v2", "nodejs");
+        },
+        service,
+        determineLocale(req)
+      );
+    }
+  }
+
+  async function getDefaultMetadata(req, service) {
+    return await prepareMetadata(
+      DefaultTenant,
+      async () => {
+        if (typeof model === "object" && !Array.isArray(model)) {
+          return model;
+        }
+        return await cds.load(model);
+      },
+      async () => {},
+      service,
+      determineLocale(req)
+    );
+  }
+
+  async function prepareMetadata(tenant, loadCsn, loadEdmx, service, locale) {
+    proxyCache[tenant] = proxyCache[tenant] || {};
+    const csn = await callCached(proxyCache[tenant], "csn", () => {
+      return prepareCSN(tenant, loadCsn);
+    });
+    if (!service) {
+      return { csn };
+    }
+    proxyCache[tenant].edmx = proxyCache[tenant].edmx || {};
+    proxyCache[tenant].edmx[service] = proxyCache[tenant].edmx[service] || {};
+    const edmx = await callCached(proxyCache[tenant].edmx[service], locale, () => {
+      return prepareEdmx(tenant, csn, loadEdmx, service, locale);
+    });
+    return { csn, edmx };
+  }
+
+  async function prepareCSN(tenant, loadCsn) {
+    let csnRaw;
+    if (cds.server && cds.model && tenant === DefaultTenant) {
+      csnRaw = cds.model;
+    } else {
+      csnRaw = await loadCsn(tenant);
+    }
+    let csn;
+    if (cds.compile.for.nodejs) {
+      csn = cds.compile.for.nodejs(csnRaw);
+    } else {
+      csn = csnRaw.meta && csnRaw.meta.transformation === "odata" ? csnRaw : cds.linked(cds.compile.for.odata(csnRaw));
+    }
+    return csn;
+  }
+
+  async function prepareEdmx(tenant, csn, loadEdmx, service, locale) {
+    let edmx;
+    if (tenant !== DefaultTenant) {
+      edmx = await loadEdmx(tenant, service, locale);
+    }
+    if (!edmx) {
+      edmx = await cds.compile.to.edmx(csn, {
+        service,
+        version: "v2",
+      });
+      edmx = cds.localize(csn, locale, edmx);
+    }
+    return edmx;
+  }
+
+  function localName(name) {
+    return name.split(".").pop();
+  }
+
+  async function callCached(cache, field, call) {
+    if (!cache[field]) {
+      cache[field] = call();
+    }
+    try {
+      return await cache[field];
+    } catch (err) {
+      delete cache[field];
+      throw err;
+    }
+  }
+
+  function localEntityName(definition, req) {
+    const parts = definition.name.split(".");
+    const localName = [parts.pop()];
+    while (parts.length > 0) {
+      const context = req.csn.definitions[parts.join(".")];
+      if (context && context.kind === "entity") {
+        localName.unshift(parts.pop());
+      } else {
+        break;
+      }
+    }
+    const nameSuffix =
+      definition.kind === "entity" &&
+      definition.params &&
+      req.context.parameters &&
+      req.context.parameters.kind === "Set"
+        ? "Set"
+        : "";
+    return localName.join("_") + nameSuffix;
+  }
+
+  function qualifiedName(name, req) {
+    const serviceNamespacePrefix = `${req.service}.`;
+    return (name.startsWith(serviceNamespacePrefix) ? "" : serviceNamespacePrefix) + name;
+  }
+
+  function lookupDefinition(name, req) {
+    const definitionName = qualifiedName(name, req);
+    return req.csn.definitions[definitionName] || req.csn.definitions[name];
+  }
+
+  function lookupBoundDefinition(name, req) {
+    let boundAction = undefined;
+    structureKeys(req.csn.definitions).find((definitionName) => {
+      const definition = req.csn.definitions[definitionName];
+      return structureKeys(definition.actions).find((actionName) => {
+        if (name.endsWith(`_${actionName}`)) {
+          const entityName = name.substr(0, name.length - `_${actionName}`.length);
+          const entityDefinition = lookupDefinition(entityName, req);
+          if (entityDefinition === definition) {
+            boundAction = definition.actions[actionName];
+            req.lookupContext.boundDefinition = definition;
+            req.lookupContext.operation = boundAction;
+            const returnDefinition = lookupReturnDefinition(boundAction.returns, req);
+            if (returnDefinition) {
+              req.lookupContext.returnDefinition = returnDefinition;
+            }
+            return true;
+          }
+        }
+        return false;
+      });
+    });
+    return boundAction;
+  }
+
+  function lookupParametersDefinition(name, req) {
+    const definitionTypeName = qualifiedName(name, req);
+    let definitionKind;
+    if (definitionTypeName.endsWith("Set")) {
+      definitionKind = "Set";
+    } else if (definitionTypeName.endsWith("Parameters")) {
+      definitionKind = "Parameters";
+    }
+    if (definitionKind) {
+      const definitionName = definitionTypeName.substring(0, definitionTypeName.length - definitionKind.length);
+      const definition = req.csn.definitions[definitionName] || req.csn.definitions[name];
+      if (definition && definition.kind === "entity" && definition.params) {
+        req.lookupContext.parameters = {
+          kind: definitionKind,
+          entity: localName(definitionName),
+          type: localName(definitionTypeName),
+          values: {},
+          keys: {},
+          count: false,
+        };
+        return definition;
+      }
+    }
+  }
+
+  function enhanceParametersDefinition(context, req) {
+    if (context && context.kind === "entity" && context.params) {
+      req.lookupContext.parameters = req.lookupContext.parameters || {
+        kind: "Parameters",
+        entity: localName(context.name),
+        type: localName(context.name),
+        values: {},
+        keys: {},
+        count: false,
+      };
+    }
+  }
+
+  /**
+   * Convert Proxy Request (v2 -> v4)
+   * @param proxyReq Proxy Request
+   * @param req Request
+   * @param res Response
+   */
+  async function convertProxyRequest(proxyReq, req, res) {
+    try {
+      // Trace
+      traceRequest(req, "Request", req.method, req.originalUrl, req.headers, req.body);
+
+      const headers = propagateHeaders(req);
+      let body = req.body;
+      let contentType = req.header("content-type");
+
+      if (isMultipartMixed(contentType)) {
+        // Multipart
+        req.contentIdOrder = [];
+        body =
+          req.method === "HEAD"
+            ? ""
+            : processMultipartMixed(
+                req,
+                req.body,
+                contentType,
+                ({ method, url }) => {
+                  return {
+                    method: method === "MERGE" ? "PATCH" : method,
+                    url: convertUrl(url, req),
+                  };
+                },
+                ({ contentType, body, headers, url, contentId }) => {
+                  if (contentId) {
+                    req.contentId[`$${contentId}`] = req.context.url;
+                  }
+                  delete headers.dataserviceversion;
+                  delete headers.DataServiceVersion;
+                  delete headers.maxdataserviceversion;
+                  delete headers.MaxDataServiceVersion;
+                  if (isApplicationJSON(contentType)) {
+                    if (ieee754Compatible) {
+                      contentType = enrichApplicationJSON(contentType);
+                      headers["content-type"] = contentType;
+                    }
+                    body = convertRequestBody(body, headers, url, req);
+                  }
+                  return { body, headers };
+                },
+                req.contentIdOrder,
+                ProcessingDirection.Request
+              );
+        headers.accept = "multipart/mixed,application/json";
+        proxyReq.setHeader("accept", headers.accept);
+      } else {
+        // Single
+        proxyReq.path = convertUrl(proxyReq.path, req);
+        if (req.context.serviceRoot && (!headers.accept || headers.accept.includes("xml"))) {
+          req.context.serviceRootAsXML = true;
+          headers.accept = "application/json";
+          proxyReq.setHeader("accept", headers.accept);
+        } else if (headers.accept && !headers.accept.includes("application/json")) {
+          headers.accept = "application/json," + headers.accept;
+          proxyReq.setHeader("accept", headers.accept);
+        }
+        if (isApplicationJSON(contentType)) {
+          if (ieee754Compatible) {
+            contentType = enrichApplicationJSON(contentType);
+            headers["content-type"] = contentType;
+          }
+          body = convertRequestBody(req.body, req.headers, proxyReq.path, req);
+        }
+      }
+
+      Object.entries(headers).forEach(([name, value]) => {
+        if (
+          name === "dataserviceversion" ||
+          name === "DataServiceVersion" ||
+          name === "maxdataserviceversion" ||
+          name === "MaxDataServiceVersion"
+        ) {
+          delete headers[name];
+          proxyReq.removeHeader(name);
+        }
+      });
+
+      if (continueOnError) {
+        headers["prefer"] = "odata.continue-on-error";
+        proxyReq.setHeader("prefer", "odata.continue-on-error");
+      }
+      headers["x-cds-odata-version"] = "v2";
+      proxyReq.setHeader("x-cds-odata-version", "v2");
+
+      if (req.body) {
+        delete req.body;
+      }
+      if (headers["x-http-method"]) {
+        proxyReq.method = headers["x-http-method"].toUpperCase();
+      }
+      proxyReq.method = proxyReq.method === "MERGE" ? "PATCH" : proxyReq.method;
+
+      if (contentType) {
+        if (body !== undefined) {
+          // File Upload
+          if (req.files && Object.keys(req.files).length === 1) {
+            const file = req.files[Object.keys(req.files)[0]];
+            contentType = body["content-type"] || file.mimetype;
+            body = file.data;
+          }
+          proxyReq.setHeader("content-type", contentType);
+          body = normalizeBody(body);
+          proxyReq.setHeader("content-length", Buffer.byteLength(body));
+          proxyReq.write(body);
+          proxyReq.end();
+        } else if ((req.header("transfer-encoding") || "").includes("chunked")) {
+          proxyReq.setHeader("content-type", contentType);
+          req.pipe(proxyReq);
+        }
+      }
+
+      // Trace
+      traceRequest(req, "ProxyRequest", proxyReq.method, proxyReq.path, headers, body);
+    } catch (err) {
+      // Error
+      logError(req, "Request", err);
+      if (err.statusCode) {
+        res.status(err.statusCode).send(err.message);
+      } else {
+        res.status(500).send("Internal Server Error");
+      }
+    }
+  }
+
+  function convertUrl(urlPath, req) {
+    let url = parseUrl(urlPath, req);
+    const definition = lookupContextFromUrl(url, req);
+    enrichRequest(definition, url, urlPath, req);
+
+    // Order is important
+    convertUrlLinks(url, req);
+    convertUrlDataTypes(url, req);
+    convertUrlCount(url, req);
+    convertDraft(url, req);
+    convertActionFunction(url, req);
+    convertFilter(url, req);
+    convertExpandSelect(url, req);
+    convertSearch(url, req);
+    convertAnalytics(url, req);
+    convertValue(url, req);
+    convertParameters(url, req);
+
+    delete url.search;
+    url.pathname = url.basePath + url.servicePath + url.contextPath;
+    return URL.format(url);
+  }
+
+  function parseUrl(urlPath, req) {
+    const url = URL.parse(urlPath, true);
+    url.pathname = (url.pathname && url.pathname.replace(/%27/g, "'")) || "";
+    url.originalUrl = { ...url, query: { ...url.query } };
+    url.basePath = "";
+    url.servicePath = "";
+    url.contextPath = url.pathname;
+    if (req.base && url.contextPath.startsWith(`/${req.base}`)) {
+      url.basePath = `/${req.base}`;
+      url.contextPath = url.contextPath.substr(url.basePath.length);
+    }
+    if (targetPath && url.contextPath.startsWith(targetPath)) {
+      url.basePath = targetPath;
+      url.contextPath = url.contextPath.substr(url.basePath.length);
+    }
+    if (url.contextPath.startsWith(`/${req.servicePath}`)) {
+      url.servicePath = `/${req.servicePath}`;
+      url.contextPath = url.contextPath.substr(url.servicePath.length);
+    }
+    if (url.contextPath.startsWith("/")) {
+      url.servicePath += "/";
+      url.contextPath = url.contextPath.substr(1);
+    }
+    url.originalUrl.servicePath = url.servicePath;
+    url.originalUrl.contextPath = url.contextPath;
+    // Normalize system and reserved query parameters (no array), others not (if array)
+    Object.keys(url.query || {}).forEach((name) => {
+      if (Array.isArray(url.query[name])) {
+        if (name.startsWith("$") || ["search", "SideEffectsQualifier"].includes(name)) {
+          url.query[name] = url.query[name][0];
+        }
+      }
+    });
+    return url;
+  }
+
+  function lookupContextFromUrl(url, req, context) {
+    req.lookupContext = {};
+    return contextFromUrl(url, req, context);
+  }
+
+  function contextFromUrl(url, req, context, suppressWarning) {
+    let stop = false;
+    return url.contextPath.split("/").reduce((context, part) => {
+      if (stop) {
+        return context;
+      }
+      const keyStart = part.indexOf("(");
+      if (keyStart !== -1) {
+        part = part.substr(0, keyStart);
+      }
+      context = lookupContext(part, context, req, suppressWarning);
+      if (!context) {
+        stop = true;
+      }
+      return context;
+    }, context);
+  }
+
+  function lookupContext(name, context, req, suppressWarning) {
+    if (!name) {
+      return context;
+    }
+    if (!context) {
+      if (name.startsWith("$") && req.contentId[name]) {
+        return contextFromUrl(req.contentId[name], req, undefined, suppressWarning);
+      } else {
+        context = lookupDefinition(name, req);
+        if (!context) {
+          context = lookupBoundDefinition(name, req);
+        }
+        if (!context) {
+          context = lookupParametersDefinition(name, req);
+        }
+        enhanceParametersDefinition(context, req);
+        if (!context && !suppressWarning) {
+          logWarning(req, "Context", "Definition name not found", {
+            name,
+          });
+        }
+        if (context && (context.kind === "function" || context.kind === "action")) {
+          req.lookupContext.operation = context;
+          const returnDefinition = lookupReturnDefinition(context.returns, req);
+          if (returnDefinition) {
+            req.lookupContext.returnDefinition = returnDefinition;
+          }
+        }
+        return context;
+      }
+    } else {
+      if (name.startsWith("$")) {
+        return context;
+      }
+      if (context.kind === "function" || context.kind === "action") {
+        req.lookupContext.operation = context;
+        const returnDefinition = lookupReturnDefinition(context.returns, req);
+        if (returnDefinition) {
+          context = returnDefinition;
+          req.lookupContext.returnDefinition = context;
+        }
+      }
+      const element = definitionElements(context)[name];
+      if (element) {
+        const type = elementType(element, req);
+        if (type === "cds.Composition" || type === "cds.Association") {
+          // Navigation
+          return element._target;
+        } else {
+          // Element
+          return context;
+        }
+      }
+      if (context && context.kind === "entity" && context.params && ["Set", "Parameters"].includes(name)) {
+        return context;
+      }
+      if (!suppressWarning) {
+        logWarning(req, "Context", "Definition name not found", {
+          name,
+        });
+      }
+    }
+  }
+
+  function enrichRequest(definition, url, urlPath, req) {
+    req.context = {
+      url,
+      urlPath,
+      serviceRoot: url.contextPath.length === 0,
+      serviceRootAsXML: false,
+      definition: definition,
+      definitionElements: definitionElements(definition),
+      requestDefinition: definition,
+      serviceUri: "",
+      operation: null,
+      boundDefinition: null,
+      returnDefinition: null,
+      bodyParameters: {},
+      $entityValue: false,
+      $value: false,
+      $count: false,
+      $apply: null,
+      aggregationKey: false,
+      aggregationFilter: "",
+      parameters: null,
+      expandSiblingEntity: false,
+      ...req.lookupContext,
+    };
+    req.contexts.push(req.context);
+    return req.context;
+  }
+
+  function convertUrlLinks(url, req) {
+    url.contextPath = url.contextPath.replace(/\/\$links\//gi, "/");
+  }
+
+  function convertUrlDataTypes(url, req) {
+    // Keys & Parameters
+    let context;
+    let stop = false;
+    url.contextPath = url.contextPath
+      .split("/")
+      .map((part) => {
+        if (stop) {
+          return part;
+        }
+        let keyPart = "";
+        const keyStart = part.indexOf("(");
+        const keyEnd = part.lastIndexOf(")");
+        if (keyStart !== -1 && keyEnd === part.length - 1) {
+          keyPart = part.substring(keyStart + 1, keyEnd);
+          part = part.substr(0, keyStart);
+        }
+        context = lookupContext(part, context, req);
+        if (!context) {
+          stop = true;
+        }
+        const contextElements = definitionElements(context);
+        const contextKeys = definitionKeys(context);
+        if (context && keyPart) {
+          const aggregationMatch =
+            keyPart.match(/^aggregation'(.*)'$/is) ||
+            keyPart.match(/^'aggregation'(.*)''$/is) ||
+            keyPart.match(/^ID__='aggregation'(.*)''$/is);
+          const aggregationKey = aggregationMatch && aggregationMatch.pop();
+          if (aggregationKey) {
+            // Aggregation Key
+            try {
+              const aggregation = JSON.parse(decodeURIKey(aggregationKey));
+              url.query["$select"] = (aggregation.value || []).join(",");
+              delete url.query["$filter"];
+              if (Object.keys(aggregation.key || {}).length > 0) {
+                url.query["$filter"] = Object.keys(aggregation.key || {})
+                  .map((name) => {
+                    return `${name} eq ${aggregation.key[name]}`;
+                  })
+                  .join(" and ");
+              }
+              if (aggregation.filter) {
+                if (!url.query["$filter"]) {
+                  url.query["$filter"] = aggregation.filter;
+                } else {
+                  url.query["$filter"] = `(${url.query["$filter"]}) and (${aggregation.filter})`;
+                }
+                req.context.aggregationFilter = aggregation.filter;
+              }
+              if (aggregation.search) {
+                url.query["search"] = aggregation.search;
+                req.context.aggregationSearch = aggregation.search;
+              }
+              req.context.aggregationKey = true;
+              return part;
+            } catch (err) {
+              // Error
+              logError(req, "AggregationKey", err);
+              return part;
+            }
+          } else {
+            const keys = decodeURIComponent(keyPart).split(",");
+            return encodeURIComponent(
+              `${part}(${keys
+                .map((key) => {
+                  const [name, value] = key.split("=");
+                  let type;
+                  if (name && value) {
+                    if (context.params && context.params[name]) {
+                      type = context.params[name].type;
+                    }
+                    if (!type) {
+                      type = elementType(contextElements[name], req);
+                    }
+                    return `${name}=${replaceConvertDataTypeToV4(value, type)}`;
+                  } else if (name) {
+                    const key = structureKeys(contextKeys).find((key) => {
+                      return contextKeys[key].type !== "cds.Composition" && contextKeys[key].type !== "cds.Association";
+                    });
+                    type = key && elementType(contextElements[key], req);
+                    return type && `${replaceConvertDataTypeToV4(name, type)}`;
+                  }
+                  return "";
+                })
+                .filter((part) => !!part)
+                .join(",")})`
+            );
+          }
+        } else {
+          return part;
+        }
+      })
+      .join("/");
+
+    // Query
+    Object.keys(url.query).forEach((name) => {
+      if (name === "$filter") {
+        url.query[name] = convertUrlDataTypesForFilter(url.query[name], context, req);
+      } else if (!name.startsWith("$")) {
+        const contextElements = definitionElements(context);
+        if (contextElements[name]) {
+          const element = contextElements[name];
+          const type = elementType(element, req);
+          if (DataTypeMap[type]) {
+            url.query[name] = replaceConvertDataTypeToV4(url.query[name], type);
+          }
+        }
+        if (context && (context.kind === "function" || context.kind === "action")) {
+          if (context.params && context.params[name]) {
+            const element = context.params[name];
+            const type = elementType(element, req);
+            if (DataTypeMap[type]) {
+              url.query[name] = replaceConvertDataTypeToV4(url.query[name], type);
+            }
+          }
+          if (context.parent && context.parent.kind === "entity") {
+            const parentElements = definitionElements(context.parent);
+            if (parentElements[name]) {
+              const element = parentElements[name];
+              const type = elementType(element, req);
+              if (DataTypeMap[type]) {
+                url.query[name] = replaceConvertDataTypeToV4(url.query[name], type);
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+
+  function buildQuoteParts(input) {
+    let quote = false;
+    let quoteEscape = false;
+    let quoteTypeStart = false;
+    let part = "";
+    const parts = [];
+    input.split("").forEach((char, index) => {
+      part += char;
+      if (char === "'") {
+        if (quote) {
+          if (quoteEscape) {
+            quoteEscape = false;
+            return;
+          }
+          const nextChar = input.substr(index + 1, 1);
+          if (nextChar === "'") {
+            quoteEscape = true;
+            return;
+          }
+        }
+        const typeStart = !!Object.keys(DataTypeMap)
+          .filter((type) => !["cds.String", "cds.LargeString"].includes(type))
+          .find((type) => {
+            const v2Pattern = DataTypeMap[type].v2;
+            return v2Pattern.includes("'") && part.endsWith(v2Pattern.split("'").shift() + "'");
+          });
+        if (!typeStart && !quoteTypeStart) {
+          if (part.length > 0) {
+            parts.push({
+              content: part,
+              quote: quote,
+            });
+            part = "";
+          }
+          quote = !quote;
+        }
+        quoteTypeStart = typeStart;
+      }
+    });
+    if (part.length > 0) {
+      parts.push({
+        content: part,
+        quote: quote,
+      });
+    }
+    return parts;
+  }
+
+  function convertUrlDataTypesForFilter(filter, context, req) {
+    if (filter === null || filter === undefined) {
+      return filter;
+    }
+    return buildQuoteParts(filter)
+      .map((part) => {
+        if (!part.quote) {
+          convertUrlDataTypesForFilterElements(part, context, req);
+        }
+        return part.content;
+      })
+      .join("");
+  }
+
+  function convertUrlDataTypesForFilterElements(part, entity, req, path = "", depth = 0) {
+    const elements = definitionElements(entity);
+    for (let name of structureKeys(elements)) {
+      const namePath = (path ? `${path}/` : "") + name;
+      if (part.content.includes(namePath)) {
+        const element = elements[name];
+        const type = elementType(element, req);
+        if (type !== "cds.Composition" && type !== "cds.Association") {
+          if (DataTypeMap[type]) {
+            const v4Regex = new RegExp(
+              `(${namePath})(\\)?\\s+?(?:eq|ne|gt|ge|lt|le)\\s+?)${DataTypeMap[type].v4.source}`,
+              DataTypeMap[type].v4.flags
+            );
+            if (v4Regex.test(part.content)) {
+              part.content = part.content.replace(v4Regex, (_, name, op, value) => {
+                return `${name}${op}${convertDataTypeToV4(value, type)}`;
+              });
+            }
+          }
+        } else if (depth < 3 && (!element.cardinality || element.cardinality.max !== "*")) {
+          convertUrlDataTypesForFilterElements(part, element._target, req, namePath, depth + 1);
+        }
+      }
+    }
+  }
+
+  function convertUrlCount(url, req) {
+    if (url.query["$inlinecount"]) {
+      url.query["$count"] = url.query["$inlinecount"] === "allpages";
+      req.context.$count = url.query["$count"];
+      delete url.query["$inlinecount"];
+    }
+    return url;
+  }
+
+  function convertDraft(url, req) {
+    if (
+      req.context &&
+      req.context.definition &&
+      req.context.definition.kind === "action" &&
+      req.context.definition.params &&
+      req.context.definition.params.SideEffectsQualifier
+    ) {
+      url.query.SideEffectsQualifier = url.query.SideEffectsQualifier || "";
+    }
+  }
+
+  function convertActionFunction(url, req) {
+    const definition = req.context && (req.context.operation || req.context.definition);
+    if (!(definition && (definition.kind === "function" || definition.kind === "action"))) {
+      return;
+    }
+    const operationLocalName = localEntityName(definition, req);
+    let reqContextPathSuffix = "";
+    if (url.contextPath.startsWith(operationLocalName)) {
+      reqContextPathSuffix = url.contextPath.substr(operationLocalName.length);
+      url.contextPath = url.contextPath.substr(0, operationLocalName.length);
+    }
+    // Key Parameters
+    if (definition.parent && definition.parent.kind === "entity") {
+      url.contextPath = localEntityName(definition.parent, req);
+      url.contextPath += `(${structureKeys(definitionKeys(definition.parent))
+        .reduce((result, name) => {
+          const parentElements = definitionElements(definition.parent);
+          const element = parentElements[name];
+          const type = elementType(element, req);
+          if (!(type === "cds.Composition" || type === "cds.Association")) {
+            const value = url.query[name];
+            result.push(`${name}=${quoteParameter(element, value, req)}`);
+            delete url.query[name];
+          }
+          return result;
+        }, [])
+        .join(",")})`;
+      url.contextPath += `/${req.service}.${definition.name}`;
+    }
+    // Function Parameters
+    if (definition.kind === "function") {
+      url.contextPath += `(${Object.keys(url.query)
+        .reduce((result, name) => {
+          if (!name.startsWith("$")) {
+            const element = definition.params && definition.params[name];
+            if (element) {
+              let value = url.query[name];
+              if (Array.isArray(value)) {
+                value = value.map((entry) => {
+                  return quoteParameter(element, encodeURIComponent(entry), req);
+                });
+              } else {
+                value = quoteParameter(element, encodeURIComponent(value), req);
+                if (element.items && element.items.type) {
+                  value = [value];
+                }
+              }
+              if (Array.isArray(value)) {
+                result.push(`${name}=@${name}Col`);
+                value = value.map((entry) => {
+                  return quoteParameter(element, entry, req, '"');
+                });
+                url.query[`@${name}Col`] = `[${value}]`;
+              } else {
+                result.push(`${name}=${value}`);
+              }
+              delete url.query[name];
+            }
+          }
+          return result;
+        }, [])
+        .join(",")})`;
+    }
+    url.contextPath += reqContextPathSuffix;
+    // Action Body
+    if (definition.kind === "action") {
+      Object.keys(url.query).forEach((name) => {
+        if (!name.startsWith("$")) {
+          const element = definition.params && definition.params[name];
+          if (element) {
+            let value = url.query[name];
+            if (Array.isArray(value)) {
+              value = value.map((entry) => {
+                return unescapeSingleQuote(element, unquoteParameter(element, entry, req), req);
+              });
+            } else {
+              value = unescapeSingleQuote(element, unquoteParameter(element, value, req), req);
+              if (element.items && element.items.type) {
+                value = [value];
+              }
+            }
+            req.context.bodyParameters[name] = value;
+            delete url.query[name];
+          }
+        }
+      });
+    }
+  }
+
+  function unescapeSingleQuote(element, value, req) {
+    if (element && value && ["cds.String", "cds.LargeString"].includes(elementType(element, req))) {
+      return value.replace(/''/g, "'");
+    }
+    return value;
+  }
+
+  function quoteParameter(element, value, req, quote = "'") {
+    if (element && ["cds.String", "cds.LargeString"].includes(elementType(element, req))) {
+      return `${quote}${unquoteParameter(element, value, req)}${quote}`;
+    }
+    return value;
+  }
+
+  function unquoteParameter(element, value, req) {
+    if (
+      element &&
+      value &&
+      [
+        "cds.String",
+        "cds.LargeString",
+        "cds.UUID",
+        "cds.Binary",
+        "cds.LargeBinary",
+        "cds.Date",
+        "cds.Time",
+        "cds.DateTime",
+        "cds.Timestamp",
+      ].includes(elementType(element, req))
+    ) {
+      return value.replace(/^['](.*)[']$/s, "$1");
+    }
+    return value;
+  }
+
+  function stripSlashes(path) {
+    return path && path.replace(/^\/|\/$/g, "");
+  }
+
+  function normalizeSlashes(path) {
+    path = stripSlashes(path);
+    return path ? `/${path}/` : "/";
+  }
+
+  function convertExpandSelect(url, req) {
+    const definition = req.context && req.context.definition;
+    if (definition) {
+      const context = { select: {}, expand: {} };
+      if (url.query["$expand"]) {
+        let expands = url.query["$expand"].split(",");
+        if (definition.kind === "entity" && definition.params) {
+          expands = expands.filter((expand) => !["Set", "Parameters"].includes(expand));
+        }
+        expands.forEach((expand) => {
+          if (fixDraftRequests && expand === "SiblingEntity") {
+            req.context.expandSiblingEntity = true;
+            return;
+          }
+          let current = context.expand;
+          expand.split("/").forEach((part) => {
+            current[part] = current[part] || { select: {}, expand: {} };
+            current = current[part].expand;
+          });
+        });
+      }
+      if (url.query["$select"]) {
+        const selects = url.query["$select"].split(",");
+        selects.forEach((select) => {
+          let current = context;
+          let currentDefinition = definition;
+          select.split("/").forEach((part) => {
+            if (!current) {
+              return;
+            }
+            const element = definitionElements(currentDefinition)[part];
+            if (element) {
+              const type = elementType(element, req);
+              if (type === "cds.Composition" || type === "cds.Association") {
+                current = current && current.expand[part];
+                currentDefinition = element._target;
+              } else if (current && current.select) {
+                current.select[part] = true;
+              }
+            }
+          });
+        });
+        if (Object.keys(context.select).length > 0) {
+          url.query["$select"] = Object.keys(context.select).join(",");
+        } else {
+          delete url.query["$select"];
+        }
+      }
+      if (url.query["$expand"]) {
+        const serializeExpand = (expand) => {
+          return Object.keys(expand || {})
+            .map((name) => {
+              let value = expand[name];
+              let result = name;
+              const selects = Object.keys(value.select);
+              const expands = Object.keys(value.expand);
+              if (selects.length > 0 || expands.length > 0) {
+                result += "(";
+                if (selects.length > 0) {
+                  result += `$select=${selects.join(",")}`;
+                }
+                if (expands.length > 0) {
+                  if (selects.length > 0) {
+                    result += ";";
+                  }
+                  result += `$expand=${serializeExpand(value.expand)}`;
+                }
+                result += ")";
+              }
+              return result;
+            })
+            .join(",");
+        };
+        if (Object.keys(context.expand).length > 0) {
+          url.query["$expand"] = serializeExpand(context.expand);
+        } else {
+          delete url.query["$expand"];
+        }
+      }
+    }
+  }
+
+  function convertFilter(url, req) {
+    const _ = "§§";
+
+    let filter = url.query["$filter"];
+    if (filter) {
+      // Fix unsupported draft requests
+      if (fixDraftRequests) {
+        const match = filter.match(UnsupportedDraftFilterRegex);
+        if (match && match.length === 3 && match[1] === match[2]) {
+          filter = filter.replace(match[0], match[1]);
+        }
+      }
+      // Convert functions
+      let quote = false;
+      let lookBehind = "";
+      let bracket = 0;
+      let brackets = [];
+      let bracketMax = 0;
+
+      filter = filter
+        .split("")
+        .map((char) => {
+          if (char === "'") {
+            quote = !quote;
+          }
+          if (!quote) {
+            if (char === "(") {
+              bracket++;
+              const filterFunctionStart = !!Object.keys(FilterFunctions).find((name) => {
+                return lookBehind.endsWith(name.split("(").shift());
+              });
+              if (filterFunctionStart) {
+                brackets.push(bracket - 1);
+                bracketMax = Math.max(bracketMax, brackets.length);
+                return `${_}(${brackets.length}${_}`;
+              }
+            } else if (char === ")") {
+              bracket--;
+              const [mark] = brackets.slice(-1);
+              if (mark === bracket) {
+                brackets.pop();
+                return `${_})${brackets.length + 1}${_}`;
+              }
+            } else if (char === ",") {
+              if (brackets.length > 0) {
+                return `${_},${brackets.length}${_}`;
+              }
+            }
+            lookBehind += char;
+          } else {
+            lookBehind = "";
+          }
+          return char;
+        })
+        .join("");
+
+      if (bracketMax > 0) {
+        for (let i = 1; i <= bracketMax; i++) {
+          Object.keys(FilterFunctions).forEach((name) => {
+            let pattern = name
+              .replace(/([()])/g, `${_}\\$1${i}${_}`)
+              .replace(/([,])/g, `${_}$1${i}${_}`)
+              .replace(/[$]/g, "(.*?)");
+            filter = filter.replace(new RegExp(pattern, "gi"), FilterFunctions[name]);
+          });
+          filter = filter.replace(new RegExp(`${_}([(),])${i}${_}`, "g"), "$1");
+        }
+        url.query["$filter"] = filter;
+      }
+    }
+  }
+
+  function convertSearch(url, req) {
+    if (url.query.search) {
+      let search = url.query.search;
+      if (quoteSearch) {
+        search = `"${search.replace(/"/g, `\\"`)}"`;
+      } else {
+        if (!/^".*"$/s.test(search) && search.includes('"')) {
+          search = `"${search.replace(/"/g, `\\"`)}"`;
+        }
+      }
+      url.query["$search"] = search;
+      delete url.query.search;
+    }
+  }
+
+  function convertAnalytics(url, req) {
+    const definition = req.context && req.context.definition;
+    if (
+      !(
+        definition &&
+        definition.kind === "entity" &&
+        definition["@cov2ap.analytics"] !== false &&
+        url.query["$select"] &&
+        (definition["@cov2ap.analytics"] === true ||
+          definition["@Analytics"] ||
+          definition["@Analytics.AnalyticalContext"] ||
+          definition["@Analytics.query"] ||
+          definition["@AnalyticalContext"] ||
+          definition["@Aggregation.ApplySupported.PropertyRestrictions"] ||
+          definition["@sap.semantics"] === "aggregate")
+      )
+    ) {
+      return;
+    }
+    const elements = req.context.definitionElements;
+    const measures = [];
+    const dimensions = [];
+    const selects = url.query["$select"].split(",");
+    const values = [];
+    selects.forEach((select) => {
+      const element = elements[select];
+      if (element) {
+        values.push(element);
+      }
+    });
+    selects.forEach((select) => {
+      const element = elements[select];
+      if (element) {
+        if (
+          element["@Analytics.AnalyticalContext.Measure"] ||
+          element["@AnalyticalContext.Measure"] ||
+          element["@Analytics.Measure"] ||
+          element["@sap.aggregation.role"] === "measure"
+        ) {
+          measures.push(element);
+        } else {
+          // element["@Analytics.AnalyticalContext.Dimension"] || element["@AnalyticalContext.Dimension"] || element["@Analytics.Dimension"] || element["@sap.aggregation.role"] === "dimension"
+          dimensions.push(element);
+        }
+      }
+    });
+
+    if (dimensions.length > 0 || measures.length > 0) {
+      url.query["$apply"] = "";
+      if (dimensions.length) {
+        url.query["$apply"] = "groupby(";
+        url.query["$apply"] += `(${dimensions
+          .map((dimension) => {
+            return dimension.name;
+          })
+          .join(",")})`;
+      }
+      if (measures.length > 0) {
+        if (url.query["$apply"]) {
+          url.query["$apply"] += ",";
+        }
+        url.query["$apply"] += `aggregate(${measures
+          .map((measure) => {
+            const aggregation = measure["@Aggregation.default"] || measure["@DefaultAggregation"];
+            const aggregationName = aggregation ? aggregation["#"] || aggregation : DefaultAggregation;
+            const aggregationFunction = aggregationName ? AggregationMap[aggregationName.toUpperCase()] : undefined;
+            if (!aggregationFunction) {
+              throw new Error(`Aggregation '${aggregationName}' is not supported`);
+            }
+            if ([AggregationMap.NONE, AggregationMap.NOP].includes(aggregationFunction)) {
+              return null;
+            }
+            if (aggregationFunction.startsWith("$")) {
+              return `${aggregationFunction} as ${AggregationPrefix}${measure.name}`;
+            } else {
+              return `${measure.name} with ${aggregationFunction} as ${AggregationPrefix}${measure.name}`;
+            }
+          })
+          .filter((aggregation) => !!aggregation)
+          .join(",")})`;
+      }
+      if (dimensions.length) {
+        url.query["$apply"] += ")";
+      }
+
+      const filter = url.query["$filter"];
+      if (filter) {
+        url.query["$apply"] = `filter(${filter})/` + url.query["$apply"];
+      }
+      const search = url.query["$search"];
+      if (search) {
+        url.query["$apply"] = `search(${search})/` + url.query["$apply"];
+      }
+
+      if (url.query["$orderby"]) {
+        url.query["$orderby"] = url.query["$orderby"]
+          .split(",")
+          .map((orderBy) => {
+            let [name, order] = orderBy.split(" ");
+            const element = elements[name];
+            if (
+              element &&
+              (element["@Analytics.AnalyticalContext.Measure"] ||
+                element["@AnalyticalContext.Measure"] ||
+                element["@Analytics.Measure"] ||
+                element["@sap.aggregation.role"] === "measure")
+            ) {
+              name = `${AggregationPrefix}${element.name}`;
+            }
+            return name + (order ? ` ${order}` : "");
+          })
+          .join(",");
+      }
+
+      delete url.query["$filter"];
+      delete url.query["$select"];
+      delete url.query["$expand"];
+      delete url.query["$search"];
+
+      req.context.$apply = {
+        key: dimensions,
+        value: values,
+        filter: req.context.aggregationKey ? req.context.aggregationFilter : filter,
+        search: req.context.aggregationKey ? req.context.aggregationSearch : search,
+      };
+    }
+  }
+
+  function convertValue(url, req) {
+    if (url.contextPath.endsWith("/$value")) {
+      url.contextPath = url.contextPath.substr(0, url.contextPath.length - "/$value".length);
+      const mediaDataElementName =
+        req.context &&
+        req.context.definition &&
+        findElementByAnnotation(req.context.definitionElements, "@Core.MediaType");
+      const endingElementName = findEndingElementName(req.context.definitionElements, url);
+      if (!endingElementName) {
+        url.contextPath += `/${mediaDataElementName}`;
+        req.context.$entityValue = true;
+      } else if (endingElementName !== mediaDataElementName) {
+        req.context.$value = true;
+      }
+    }
+  }
+
+  function convertParameters(url, req) {
+    if (req.context.parameters) {
+      let context;
+      let stop = false;
+      url.contextPath = url.contextPath
+        .split("/")
+        .map((part) => {
+          if (part === "Set" || part.startsWith("Set(")) {
+            req.context.parameters.kind = "Set";
+            stop = true;
+          } else if (part === "Parameters" || part.startsWith("Parameters(")) {
+            req.context.parameters.kind = "Parameters";
+            stop = true;
+          } else if (part === "$count") {
+            req.context.parameters.count = true;
+          }
+          if (stop) {
+            return "";
+          }
+          let keyPart = "";
+          const keyStart = part.indexOf("(");
+          const keyEnd = part.lastIndexOf(")");
+          if (keyStart !== -1 && keyEnd === part.length - 1) {
+            keyPart = part.substring(keyStart + 1, keyEnd);
+            part = part.substr(0, keyStart);
+          }
+          if (part === req.context.parameters.type) {
+            part = req.context.parameters.entity;
+          }
+          context = lookupContext(part, context, req);
+          if (!context) {
+            stop = true;
+          }
+          const contextElements = definitionElements(context);
+          if (context && keyPart) {
+            const keys = decodeURIComponent(keyPart).split(",");
+            return encodeURIComponent(
+              `${part}(${keys
+                .map((key) => {
+                  const [name, value] = key.split("=");
+                  if (name && value) {
+                    if (context.params[name]) {
+                      req.context.parameters.values[name] = unquoteParameter(context.params[name], value, req);
+                      return `${name}=${value}`;
+                    } else {
+                      req.context.parameters.keys[name] = unquoteParameter(contextElements[name], value, req);
+                    }
+                  } else if (name) {
+                    const param = structureKeys(context.params).find(() => true);
+                    if (param) {
+                      if (context.params[param]) {
+                        req.context.parameters.values[param] = unquoteParameter(context.params[param], name, req);
+                        return `${param}=${name}`;
+                      } else {
+                        req.context.parameters.keys[param] = unquoteParameter(contextElements[param], name, req);
+                      }
+                    }
+                  }
+                  return "";
+                })
+                .filter((part) => !!part)
+                .join(",")})`
+            );
+          } else {
+            return part;
+          }
+        })
+        .filter((part) => !!part)
+        .join("/");
+      if (!url.contextPath.endsWith("/Set")) {
+        url.contextPath = `${url.contextPath}/Set`;
+      }
+      if (req.context.parameters.count) {
+        url.contextPath += "/$count";
+      }
+    }
+  }
+
+  function convertRequestBody(body, headers, url, req) {
+    let definition = req.context && req.context.definition;
+    if (definition) {
+      if (definition.kind === "action") {
+        body = Object.assign({}, body, req.context.bodyParameters);
+        definition = {
+          elements: definition.params || {},
+        };
+      }
+      convertRequestData(body, headers, definition, req);
+    }
+    return JSON.stringify(body);
+  }
+
+  function convertRequestData(data, headers, definition, req) {
+    if (!Array.isArray(data)) {
+      return convertRequestData([data], headers, definition, req);
+    }
+    const elements = definitionElements(definition);
+    if (structureKeys(elements).length === 0) {
+      return;
+    }
+    // Modify Payload
+    data.forEach((data) => {
+      delete data.__metadata;
+      delete data.__count;
+      convertDataTypesToV4(data, headers, definition, elements, req);
+    });
+    // Recursion
+    data.forEach((data) => {
+      Object.keys(data).forEach((key) => {
+        const element = elements[key];
+        const type = elementType(element, req);
+        if (element && (type === "cds.Composition" || type === "cds.Association")) {
+          if (data[key] && data[key].__deferred) {
+            delete data[key];
+          } else {
+            if (data[key] !== null) {
+              if (Array.isArray(data[key].results)) {
+                data[key] = data[key].results;
+              }
+              convertRequestData(data[key], headers, element._target, req);
+            } else {
+              delete data[key];
+            }
+          }
+        }
+      });
+    });
+  }
+
+  function convertDataTypesToV4(data, headers, definition, elements, req) {
+    Object.keys(data || {}).forEach((key) => {
+      if (data[key] === null) {
+        return;
+      }
+      const element = elements[key];
+      if (element) {
+        data[key] = convertDataTypeToV4(data[key], elementType(element, req), definition, headers);
+      }
+    });
+  }
+
+  function replaceConvertDataTypeToV4(value, type, definition, headers = {}) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => {
+        return replaceConvertDataTypeToV4(entry, type, definition, headers);
+      });
+    }
+    if (DataTypeMap[type]) {
+      value = value.replace(DataTypeMap[type].v4, "$1");
+    }
+    return convertDataTypeToV4(value, type);
+  }
+
+  function convertDataTypeToV4(value, type, definition, headers = {}) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => {
+        return convertDataTypeToV4(entry, type, definition, headers);
+      });
+    }
+    const contentType = headers["content-type"];
+    const ieee754Compatible = contentType && contentType.includes(IEEE754Compatible);
+    if (["cds.Boolean"].includes(type)) {
+      if (value === "true") {
+        value = true;
+      } else if (value === "false") {
+        value = false;
+      }
+    } else if (["cds.Integer"].includes(type)) {
+      value = parseInt(value, 10);
+    } else if (["cds.Integer64", "cds.Decimal", "cds.DecimalFloat"].includes(type)) {
+      value = ieee754Compatible ? `${value}` : parseFloat(value);
+    } else if (["cds.Double"].includes(type)) {
+      value = parseFloat(value);
+    } else if (["cds.Time"].includes(type)) {
+      const match = value.match(DurationRegex);
+      if (match) {
+        value = `${match[4] || "00"}:${match[5] || "00"}:${match[6] || "00"}`;
+      }
+    } else if (["cds.Date", "cds.DateTime", "cds.Timestamp"].includes(type)) {
+      const match = value.match(/\/Date\((.*)\)\//is);
+      const ticksAndOffset = match && match.pop();
+      if (ticksAndOffset !== undefined && ticksAndOffset !== null) {
+        value = new Date(calculateTicksOffsetSum(ticksAndOffset)).toISOString(); // always UTC
+      }
+      if (["cds.DateTime"].includes(type)) {
+        value = value.slice(0, 19) + "Z"; // Cut millis
+      } else if (["cds.Date"].includes(type)) {
+        value = value.slice(0, 10); // Cut time
+      }
+    }
+    return value;
+  }
+
+  function calculateTicksOffsetSum(text) {
+    return (text.replace(/\s/g, "").match(/[+-]?([0-9]+)/g) || []).reduce((sum, value, index) => {
+      return sum + parseFloat(value) * (index === 0 ? 1 : 60 * 1000); // ticks are milliseconds (0), offset are minutes (1)
+    }, 0);
+  }
+
+  function initContext(req, index = 0) {
+    req.context = req.contexts[index] || {};
+    return req.context.definition && req.context.definition.kind === "entity"
+      ? req.context.definition
+      : req.context.boundDefinition;
+  }
+
+  /**
+   * Convert Proxy Response (v4 -> v2)
+   * @param proxyRes Proxy Request
+   * @param req Request
+   * @param res Response
+   */
+  async function convertProxyResponse(proxyRes, req, res) {
+    try {
+      req.context = {};
+      let statusCode = proxyRes.statusCode;
+      let headers = proxyRes.headers;
+      if (statusCode < 400 && req.overwriteResponse) {
+        statusCode = req.overwriteResponse.statusCode;
+        headers = {
+          ...req.overwriteResponse.headers,
+          ...headers,
+        };
+      }
+
+      normalizeContentType(headers);
+
+      // Pipe Binary Stream
+      const contentType = headers["content-type"];
+      const transferEncoding = headers["transfer-encoding"] || "";
+      if (transferEncoding.includes("chunked") && !isApplicationJSON(contentType) && !isMultipartMixed(contentType)) {
+        return await processStreamResponse(proxyRes, req, res, headers);
+      }
+
+      // Body
+      let body = await parseProxyResponseBody(proxyRes, headers, req);
+      if (statusCode < 400 && req.overwriteResponse) {
+        body = {
+          ...req.overwriteResponse.body,
+          ...body,
+        };
+      }
+
+      // Trace
+      traceResponse(req, "ProxyResponse", proxyRes.statusCode, proxyRes.statusMessage, headers, body);
+      delete headers["content-encoding"];
+
+      convertBasicHeaders(headers);
+      if (body && statusCode < 400) {
+        if (isMultipartMixed(contentType)) {
+          // Multipart
+          const resContentIdOrder = [];
+          body = processMultipartMixed(
+            req,
+            body,
+            contentType,
+            null,
+            ({ index, statusCode, contentType, body, headers }) => {
+              const serviceDefinition = initContext(req, index);
+              if (statusCode < 400) {
+                convertHeaders(body, headers, serviceDefinition, req);
+                if (body && isApplicationJSON(contentType)) {
+                  body = convertResponseBody(Object.assign({}, body), headers, req);
+                }
+              } else {
+                convertHeaders(body, headers, serviceDefinition, req);
+                body = convertResponseError(body, headers, serviceDefinition, req);
+              }
+              return { body, headers };
+            },
+            resContentIdOrder,
+            ProcessingDirection.Response
+          );
+          if (
+            !(
+              req.contentIdOrder.length === resContentIdOrder.length &&
+              req.contentIdOrder.every((contentId, index) => contentId === resContentIdOrder[index])
+            )
+          ) {
+            logWarning(req, "Batch", "Response changeset order does not match request changeset order", {
+              requestContentIds: req.contentIdOrder,
+              responseContentIds: resContentIdOrder,
+            });
+          }
+          if (statusCode === 200) {
+            // OData V4: 200 => OData V2: 202
+            statusCode = 202;
+          }
+        } else {
+          // Single
+          const serviceDefinition = initContext(req);
+          convertHeaders(body, headers, serviceDefinition, req);
+          if (isApplicationJSON(contentType)) {
+            body = convertResponseBody(Object.assign({}, body), headers, req);
+          }
+        }
+        if (body && !(headers["transfer-encoding"] || "").includes("chunked") && statusCode !== 204) {
+          setContentLength(headers, body);
+        }
+      } else {
+        // Failed
+        const serviceDefinition = initContext(req);
+        convertHeaders(body, headers, serviceDefinition, req);
+        body = convertResponseError(body, headers, serviceDefinition, req);
+        setContentLength(headers, body);
+      }
+      respond(req, res, statusCode, headers, body);
+    } catch (err) {
+      // Error
+      logError(req, "Response", err);
+      if (proxyRes.body && proxyRes.body.error) {
+        respond(
+          req,
+          res,
+          proxyRes.statusCode,
+          proxyRes.headers,
+          convertResponseError(proxyRes.body, proxyRes.headers, undefined, req)
+        );
+      } else {
+        res.status(500).send("Internal Server Error");
+      }
+    }
+  }
+
+  async function processStreamResponse(proxyRes, req, res, headers) {
+    // Trace
+    traceResponse(req, "ProxyResponse", proxyRes.statusCode, proxyRes.statusMessage, headers, {});
+
+    let streamRes = proxyRes;
+    convertBasicHeaders(headers);
+    const context = req.contexts && req.contexts[0];
+    if (context && context.definition && context.definitionElements) {
+      const mediaDataElementName = findElementByAnnotation(context.definitionElements, "@Core.MediaType");
+      if (mediaDataElementName) {
+        const parts = proxyRes.req.path.split("/");
+        if (parts[parts.length - 1] === "$value" || parts[parts.length - 1].startsWith("$value?")) {
+          parts.pop();
+        }
+        if (parts[parts.length - 1] === mediaDataElementName) {
+          parts.pop();
+        }
+
+        // Is Url
+        const urlElement =
+          findElementByAnnotation(context.definitionElements, "@Core.IsURL") ||
+          findElementByAnnotation(context.definitionElements, "@Core.IsUrl");
+        if (urlElement) {
+          const mediaResponse = await fetch(target + parts.join("/"), {
+            method: "GET",
+            headers: propagateHeaders(req, {
+              accept: "application/json",
+            }),
+          });
+          if (!mediaResponse.ok) {
+            throw new Error(await mediaResponse.text());
+          }
+          if (mediaResponse) {
+            const mediaResult = await mediaResponse.json();
+            const mediaReadLink = mediaResult[`${urlElement}@odata.mediaReadLink`];
+            if (mediaReadLink) {
+              try {
+                const mediaResponse = await fetch(mediaReadLink, {
+                  method: "GET",
+                  headers: propagateHeaders(req),
+                });
+                res.status(mediaResponse.status);
+                headers = convertBasicHeaders(convertToNodeHeaders(mediaResponse.headers));
+                streamRes = mediaResponse.body;
+              } catch (err) {
+                logError(req, "MediaStream", err);
+                const errorBody = convertResponseError({ error: err }, {}, context.definition, req);
+                respond(req, res, 500, { "content-type": "application/json" }, errorBody);
+                return;
+              }
+            }
+          }
+        } else {
+          if (!headers["content-disposition"] || calcContentDisposition) {
+            // Is Binary
+            const contentDispositionFilenameElement =
+              findElementValueByAnnotation(context.definitionElements, "@Core.ContentDisposition.Filename") ||
+              findElementValueByAnnotation(context.definitionElements, "@Common.ContentDisposition.Filename");
+            if (contentDispositionFilenameElement) {
+              const contentDispositionTypeValue =
+                findElementValueByAnnotation(context.definitionElements, "@Core.ContentDisposition.Type") ||
+                findElementValueByAnnotation(context.definitionElements, "@Common.ContentDisposition.Type") ||
+                contentDisposition;
+              const response = await fetch(target + [...parts, contentDispositionFilenameElement, "$value"].join("/"), {
+                method: "GET",
+                headers: propagateHeaders(req, {
+                  accept: "application/json,*/*",
+                }),
+              });
+              if (response.ok) {
+                const filename = await response.text();
+                if (filename) {
+                  headers["content-disposition"] = `${contentDispositionTypeValue}; filename="${encodeURIComponent(
+                    filename
+                  )}"`;
+                }
+              } else {
+                logWarning(req, "ContentDisposition", await response.text());
+              }
+            }
+          }
+        }
+      }
+    }
+
+    delete headers["content-encoding"];
+    Object.entries(headers).forEach(([name, value]) => {
+      res.setHeader(name, value);
+    });
+    streamRes.pipe(res);
+
+    // Trace
+    traceResponse(req, "Response", res.statusCode, res.statusMessage, headers, {});
+  }
+
+  async function parseProxyResponseBody(proxyRes, headers, req) {
+    const contentType = headers["content-type"];
+    let bodyParser;
+    if (req.method === "HEAD") {
+      bodyParser = null;
+    } else if (isApplicationJSON(contentType)) {
+      bodyParser = express.json({ limit: bodyParserLimit });
+    } else if (isPlainText(contentType) || isXML(contentType)) {
+      bodyParser = express.text({ type: () => true, limit: bodyParserLimit });
+    } else if (isMultipartMixed(contentType)) {
+      bodyParser = express.text({ type: "multipart/mixed", limit: bodyParserLimit });
+    }
+    if (bodyParser) {
+      await promisify(bodyParser)(proxyRes, null);
+      return proxyRes.body;
+    }
+  }
+
+  function convertBasicHeaders(headers) {
+    delete headers["odata-version"];
+    delete headers["OData-Version"];
+    delete headers["odata-entityid"];
+    delete headers["OData-EntityId"];
+    headers.dataserviceversion = "2.0";
+    return headers;
+  }
+
+  function convertHeaders(body, headers, serviceDefinition, req) {
+    convertBasicHeaders(headers);
+    const definition = contextFromBody(body, req);
+    if (definition && definition.kind === "entity") {
+      const elements = definitionElements(definition);
+      convertLocation(body, headers, definition, elements, req);
+    }
+    convertMessages(body, headers, definition && definition.kind === "entity" ? definition : serviceDefinition, req);
+    return headers;
+  }
+
+  function convertLocation(body, headers, definition, elements, req) {
+    if (headers.location || headers.Location) {
+      headers.location = entityUri(body, definition, elements, req);
+    }
+    delete headers.Location;
+  }
+
+  function convertMessages(body, headers, definition, req) {
+    if (headers["sap-messages"]) {
+      const messages = JSON.parse(headers["sap-messages"]);
+      if (messages && messages.length > 0) {
+        const rootMessage = messages.shift();
+        rootMessage.details = Array.isArray(rootMessage.details) ? rootMessage.details : [];
+        rootMessage.details.push(...messages);
+        const message = convertMessage(rootMessage, definition, req);
+        headers["sap-message"] = JSON.stringify(message);
+      }
+      delete headers["sap-messages"];
+    }
+  }
+
+  function convertMessage(message, definition, req, contentID) {
+    if (!message) {
+      return message;
+    }
+    message.severity = SeverityMap[message["@Common.numericSeverity"] || message.numericSeverity] || "error";
+    delete message.numericSeverity;
+    delete message["@Common.numericSeverity"];
+    if (message.target) {
+      message.target = convertMessageTarget(message.target, req, definition);
+    } else if (message.target === undefined && messageTargetDefault) {
+      message.target = messageTargetDefault;
+    }
+    if (Array.isArray(message["@Common.additionalTargets"])) {
+      message.additionalTargets = message["@Common.additionalTargets"].map((messageTarget) => {
+        return convertMessageTarget(messageTarget, req, definition);
+      });
+    }
+    delete message["@Common.additionalTargets"];
+    contentID = message["@Core.ContentID"] || contentID;
+    message.ContentID = contentID;
+    delete message["@Core.ContentID"];
+    if (Array.isArray(message.details)) {
+      message.details = message.details.map((detail) => {
+        return convertMessage(detail, definition, req, contentID);
+      });
+      if (propagateMessageToDetails) {
+        const propagatedDetailMessage = Object.assign({}, message);
+        delete propagatedDetailMessage.details;
+        message.details.unshift(propagatedDetailMessage);
+      }
+      message.details.forEach((detail) => {
+        if (detail.code && detail.code.toLowerCase().includes("transition")) {
+          detail.transition = true;
+        }
+      });
+    }
+    return message;
+  }
+
+  function convertMessageTarget(messageTarget, req, definition) {
+    if (!messageTarget) {
+      return messageTarget;
+    }
+    if (req.context.operation && req.context.boundDefinition) {
+      const bindingParamaterName = req.context.operation["@cds.odata.bindingparameter.name"] || "in";
+      if (messageTarget.startsWith(`${bindingParamaterName}/`)) {
+        messageTarget = messageTarget.substr(bindingParamaterName.length + 1);
+      }
+    }
+    let context;
+    definition = definition && definition.kind === "entity" ? definition : undefined;
+    if (
+      contextFromUrl(
+        {
+          contextPath: messageTarget,
+          query: {},
+        },
+        req,
+        undefined,
+        true
+      )
+    ) {
+      context = undefined;
+    } else if (
+      contextFromUrl(
+        {
+          contextPath: messageTarget,
+          query: {},
+        },
+        req,
+        definition,
+        true
+      )
+    ) {
+      context = definition;
+    }
+    let stop = false;
+    return messageTarget
+      .split("/")
+      .map((part) => {
+        if (stop) {
+          return part;
+        }
+        let keyPart = "";
+        const keyStart = part.indexOf("(");
+        const keyEnd = part.lastIndexOf(")");
+        if (keyStart !== -1 && keyEnd === part.length - 1) {
+          keyPart = part.substring(keyStart + 1, keyEnd);
+          part = part.substr(0, keyStart);
+        }
+        context = lookupContext(part, context, req);
+        if (!context) {
+          stop = true;
+        }
+        const contextElements = definitionElements(context);
+        const contextKeys = definitionKeys(context);
+        if (context && keyPart) {
+          const keys = keyPart.split(",");
+          return `${part}(${keys
+            .map((key) => {
+              const [name, value] = key.split("=");
+              let type;
+              if (name && value) {
+                if (context.params && context.params[name]) {
+                  type = context.params[name].type;
+                }
+                if (!type) {
+                  type = elementType(contextElements[name], req);
+                }
+                return `${name}=${replaceConvertDataTypeToV2(value, type, context)}`;
+              } else if (name) {
+                const key = structureKeys(contextKeys).find((key) => {
+                  return contextKeys[key].type !== "cds.Composition" && contextKeys[key].type !== "cds.Association";
+                });
+                type = key && elementType(contextElements[key], req);
+                return type && `${replaceConvertDataTypeToV2(name, type, context)}`;
+              }
+              return "";
+            })
+            .filter((part) => !!part)
+            .join(",")})`;
+        } else {
+          return part;
+        }
+      })
+      .join("/");
+  }
+
+  function convertResponseError(body, headers, definition, req) {
+    if (!body) {
+      return body;
+    }
+    if (body.error) {
+      if (body.error.message) {
+        body.error.message = {
+          lang: headers["content-language"] || "en",
+          value: body.error.message,
+        };
+      }
+      body.error = convertMessage(body.error, definition, req);
+      body.error.innererror = body.error.innererror || {};
+      body.error.innererror.errordetails = body.error.innererror.errordetails || [];
+      body.error.innererror.errordetails.push(...(body.error.details || []));
+      delete body.error.details;
+      if (body.error.innererror.errordetails.length === 0) {
+        const singleDetailError = Object.assign({}, body.error);
+        delete singleDetailError.innererror;
+        delete singleDetailError.details;
+        if (body.error.innererror.errordetails.length === 0) {
+          body.error.innererror.errordetails.push(singleDetailError);
+        }
+      }
+    }
+    if (typeof body === "object") {
+      body = JSON.stringify(body);
+    }
+    body = `${body}`;
+    setContentLength(headers, body);
+    return body;
+  }
+
+  function convertResponseBody(proxyBody, headers, req) {
+    const body = {
+      d: {},
+    };
+    if (req.context.serviceRoot && proxyBody.value) {
+      if (req.context.serviceRootAsXML) {
+        // Service Root XML
+        let xmlBody = `<?xml version="1.0" encoding="utf-8" standalone="yes" ?>`;
+        xmlBody += `<service xml:base="${serviceUri(
+          req
+        )}" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:app="http://www.w3.org/2007/app" xmlns="http://www.w3.org/2007/app">`;
+        xmlBody += `<workspace><atom:title>Default</atom:title>`;
+        xmlBody += proxyBody.value
+          .map((entry) => {
+            return `<collection href="${entry.name}"><atom:title>${entry.name}</atom:title></collection>`;
+          })
+          .join("");
+        xmlBody += `</workspace></service>`;
+        headers["content-type"] = "application/xml";
+        return xmlBody;
+      } else {
+        // Service Root JSON
+        body.d.EntitySets = proxyBody.value.map((entry) => {
+          return entry.name;
+        });
+      }
+    } else {
+      // Context from Body
+      const definition = contextFromBody(proxyBody, req);
+      if (definition) {
+        req.context.requestDefinition = req.context.definition;
+        req.context.definition = definition;
+        req.context.definitionElements = definitionElements(definition);
+        const elements = req.context.definitionElements;
+        const definitionElement = contextElementFromBody(proxyBody, req);
+        if (definitionElement) {
+          body.d[definitionElement.name] = proxyBody.value;
+          convertResponseElementData(body, headers, definition, elements, proxyBody, req);
+          if (req.context.$value) {
+            headers["content-type"] = "text/plain";
+            return `${body.d[definitionElement.name]}`;
+          }
+        } else {
+          const data = convertResponseList(body, headers, definition, proxyBody, req);
+          convertResponseData(data, headers, definition, proxyBody, req);
+        }
+      } else {
+        // Context from Request
+        let definition = req.context.definition;
+        if (definition && (definition.kind === "function" || definition.kind === "action")) {
+          const returnDefinition = req.context.returnDefinition;
+          if (!returnDefinition || returnDefinition.name) {
+            definition = returnDefinition;
+          } else {
+            definition = {
+              kind: "type",
+              name: contextNameFromBody(proxyBody),
+              ...returnDefinition,
+            };
+          }
+          req.context.requestDefinition = req.context.definition;
+          req.context.definition = definition;
+          req.context.definitionElements = definitionElements(definition);
+        }
+        const data = convertResponseList(body, headers, definition, proxyBody, req);
+        convertResponseData(data, headers, definition, proxyBody, req);
+      }
+    }
+
+    if (req.context.operation) {
+      const localOperationName = localName(req.context.operation.name);
+      const isArrayResult = Array.isArray(body.d.results) || Array.isArray(body.d);
+      if (req.context.definition.kind === "type") {
+        if (returnComplexNested && !isArrayResult) {
+          body.d = {
+            [localOperationName]: body.d,
+          };
+        }
+      } else if (!req.context.definition.kind && req.context.definition.name && req.context.definitionElements.value) {
+        if (returnPrimitivePlain) {
+          body.d = isArrayResult ? (body.d.results || body.d).map((entry) => entry.value) : body.d.value;
+        }
+        if (returnPrimitiveNested) {
+          body.d = isArrayResult
+            ? {
+                results: body.d,
+              }
+            : {
+                [localOperationName]: body.d,
+              };
+        }
+      }
+    }
+
+    return JSON.stringify(body);
+  }
+
+  function convertResponseList(body, headers, definition, proxyBody, req) {
+    if (Array.isArray(proxyBody.value)) {
+      if (req.context.aggregationKey) {
+        proxyBody = proxyBody.value[0] || {};
+      } else {
+        body.d.results = proxyBody.value || [];
+        if (req.context.$count) {
+          body.d.__count = String(proxyBody["@odata.count"] || proxyBody["@count"] || 0);
+        }
+        if (proxyBody["@odata.nextLink"] !== undefined || proxyBody["@nextLink"] !== undefined) {
+          const skipToken = URL.parse(proxyBody["@odata.nextLink"] || proxyBody["@nextLink"], true).query["$skiptoken"];
+          if (skipToken) {
+            body.d.__next = linkUri(req, {
+              $skiptoken: skipToken,
+            });
+          }
+        }
+        let deltaToken;
+        if (proxyBody["@odata.deltaLink"] !== undefined || proxyBody["@deltaLink"] !== undefined) {
+          deltaToken = URL.parse(proxyBody["@odata.deltaLink"] || proxyBody["@deltaLink"], true).query["!deltatoken"];
+        }
+        if (!deltaToken && definition && definition["@cov2ap.deltaResponse"] === "timestamp") {
+          deltaToken = `'${new Date().getTime()}'`;
+        }
+        if (deltaToken) {
+          body.d.__delta = linkUri(req, {
+            "!deltatoken": deltaToken,
+          });
+        }
+        body.d.results = body.d.results.map((entry) => {
+          return typeof entry == "object" ? entry : { value: entry };
+        });
+        if (req.context.parameters) {
+          if (req.context.parameters.kind === "Parameters") {
+            body.d.results = body.d.results.slice(0, 1);
+          } else if (req.context.parameters.kind === "Set") {
+            if (Object.keys(req.context.parameters.keys).length > 0) {
+              body.d.results = body.d.results.filter((entry) => {
+                return Object.keys(req.context.parameters.keys).every((key) => {
+                  return entry[key] === req.context.parameters.keys[key];
+                });
+              });
+            }
+          }
+        }
+        if (!returnCollectionNested) {
+          body.d = body.d.results;
+          return body.d;
+        }
+        return body.d.results;
+      }
+    }
+    body.d = proxyBody;
+    return [body.d];
+  }
+
+  function convertResponseData(data, headers, definition, proxyBody, req) {
+    if (data === null) {
+      return;
+    }
+    if (!Array.isArray(data)) {
+      return convertResponseData([data], headers, definition, proxyBody, req);
+    }
+    if (!definition) {
+      return;
+    }
+    const elements = definitionElements(definition);
+    // Recursion
+    data.forEach((data) => {
+      Object.keys(data).forEach((key) => {
+        let element = elements[key];
+        if (!element) {
+          return;
+        }
+        const type = elementType(element, req);
+        if (type === "cds.Composition" || type === "cds.Association") {
+          convertResponseData(data[key], headers, element._target, proxyBody, req);
+        }
+      });
+    });
+    // Structural Changes
+    data.forEach((data) => {
+      addResultsNesting(data, headers, definition, elements, proxyBody, req);
+    });
+    // Deferreds
+    data.forEach((data) => {
+      addDeferreds(data, headers, definition, elements, proxyBody, req);
+    });
+    // Modify Payload
+    data.forEach((data) => {
+      addMetadata(data, headers, definition, elements, proxyBody, req);
+      removeMetadata(data, headers, definition, elements, proxyBody, req);
+      convertMedia(data, headers, definition, elements, proxyBody, req);
+      removeAnnotations(data, headers, definition, elements, proxyBody, req);
+      convertDataTypesToV2(data, headers, definition, elements, proxyBody, req);
+      convertAggregation(data, headers, definition, elements, proxyBody, req);
+      filterParameters(data, headers, definition, elements, proxyBody, req);
+    });
+  }
+
+  function convertResponseElementData(data, headers, definition, elements, proxyBody, req) {
+    if (!definition) {
+      return;
+    }
+    // Modify Payload
+    convertDataTypesToV2(data, headers, definition, elements, proxyBody, req);
+  }
+
+  function contextNameFromBody(body) {
+    let context = body && (body["@odata.context"] || body["@context"]);
+    if (!context) {
+      return;
+    }
+    context = context.substr(context.indexOf("#") + 1);
+    if (context.startsWith("Collection(")) {
+      context = context.substring("Collection(".length, context.indexOf(")"));
+    } else {
+      if (context.indexOf("(") !== -1) {
+        context = context.substr(0, context.indexOf("("));
+      }
+    }
+    if (context.indexOf("/") !== -1) {
+      context = context.substr(0, context.indexOf("/"));
+    }
+    return context;
+  }
+
+  function contextFromBody(body, req) {
+    const context = contextNameFromBody(body);
+    if (context) {
+      return lookupDefinition(context, req);
+    }
+  }
+
+  function contextElementFromBody(body, req) {
+    let context = body["@odata.context"] || body["@context"];
+    const definition = contextFromBody(body, req);
+    if (!(context && definition)) {
+      return null;
+    }
+    if (context.lastIndexOf("/") !== -1) {
+      const name = context.substr(context.lastIndexOf("/") + 1);
+      if (name && !name.startsWith("$")) {
+        const element = definitionElements(definition)[name];
+        if (element) {
+          return element;
+        }
+      }
+    }
+  }
+
+  function addMetadata(data, headers, definition, elements, body, req) {
+    const typeSuffix =
+      definition.kind === "entity" && definition.params && req.context.parameters
+        ? req.context.parameters.kind === "Set"
+          ? "Type"
+          : "Parameters"
+        : "";
+    data.__metadata = {
+      type: definition.name + typeSuffix,
+    };
+    if (definition.kind === "entity") {
+      data.__metadata.uri = entityUri(data, definition, elements, req);
+      if (data["@odata.etag"] || data["@etag"]) {
+        data.__metadata.etag = data["@odata.etag"] || data["@etag"];
+      }
+      const mediaDataElementName = findElementByAnnotation(elements, "@Core.MediaType");
+      if (mediaDataElementName) {
+        data.__metadata.media_src = `${data.__metadata.uri}/$value`;
+        const mediaDataElement = elements[mediaDataElementName];
+        const mediaTypeElementName =
+          (mediaDataElement["@Core.MediaType"] && mediaDataElement["@Core.MediaType"]["="]) ||
+          findElementByAnnotation(elements, "@Core.IsMediaType");
+        if (mediaTypeElementName) {
+          data.__metadata.content_type = data[mediaTypeElementName];
+        } else if (mediaDataElement["@Core.MediaType"]) {
+          data.__metadata.content_type = mediaDataElement["@Core.MediaType"];
+        }
+        if (!data.__metadata.content_type) {
+          data.__metadata.content_type = "application/octet-stream";
+        }
+      }
+    }
+  }
+
+  function removeMetadata(data, headers, definition, elements, body, req) {
+    Object.keys(data).forEach((key) => {
+      if (key.startsWith("@") || key.startsWith("odata.") || key.includes("@odata.")) {
+        delete data[key];
+      }
+    });
+  }
+
+  function convertMedia(data, headers, definition, elements, proxyBody, req) {
+    Object.keys(data).forEach((key) => {
+      if (key.endsWith("@odata.mediaReadLink")) {
+        data[key.split("@odata.mediaReadLink")[0]] = data[key];
+      } else if (key.endsWith("@mediaReadLink")) {
+        data[key.split("@mediaReadLink")[0]] = data[key];
+      }
+    });
+  }
+
+  function removeAnnotations(data, headers, definition, elements, proxyBody, req) {
+    Object.keys(data).forEach((key) => {
+      if (key.startsWith("@")) {
+        delete data[key];
+      }
+    });
+  }
+
+  function convertAggregation(data, headers, definition, elements, body, req) {
+    if (!req.context.$apply) {
+      return;
+    }
+    Object.keys(data).forEach((key) => {
+      let value = data[key];
+      if (key.startsWith(AggregationPrefix)) {
+        if (!(key.endsWith("@odata.type") || key.endsWith("@type"))) {
+          const name = key.substr(AggregationPrefix.length);
+          let aggregationType = (data[`${key}@odata.type`] || data[`${key}@type`] || "#Decimal").replace("#", "");
+          if (DataTypeOData[aggregationType]) {
+            aggregationType = DataTypeOData[aggregationType];
+          } else {
+            aggregationType = `cds.${aggregationType}`;
+          }
+          if (
+            ["cds.Integer", "cds.Integer64", "cds.Double", "cds.Decimal", "cds.DecimalFloat"].includes(aggregationType)
+          ) {
+            if (value === null || value === "null") {
+              value = 0;
+            }
+          } else if (["cds.String", "cds.LargeString"].includes(aggregationType)) {
+            if (value === null) {
+              value = "";
+            }
+          } else if (["cds.Boolean"].includes(aggregationType)) {
+            if (value === null) {
+              value = false;
+            }
+          }
+          let aggregationValue = convertDataTypeToV2(value, aggregationType, definition);
+          // Convert to JSON number
+          const element = req.context.$apply.value.find((entry) => {
+            return entry.name === name;
+          });
+          if (element && elementType(element, req) === "cds.Integer") {
+            const aggregation = element["@Aggregation.default"] || element["@DefaultAggregation"];
+            const aggregationName = aggregation ? aggregation["#"] || aggregation : DefaultAggregation;
+            const aggregationFunction = aggregationName ? AggregationMap[aggregationName.toUpperCase()] : undefined;
+            if (
+              aggregationType === "cds.Decimal" &&
+              aggregationFunction &&
+              ![AggregationMap.AVG, AggregationMap.COUNT_DISTINCT].includes(aggregationFunction)
+            ) {
+              const floatValue = parseFloat(aggregationValue);
+              if (aggregationValue === `${floatValue}`) {
+                aggregationValue = floatValue;
+              }
+            }
+          }
+          data[name] = aggregationValue;
+          delete data[key];
+        }
+      }
+    });
+    Object.keys(data).forEach((key) => {
+      if (key.startsWith(AggregationPrefix) && (key.endsWith("@odata.type") || key.endsWith("@type"))) {
+        delete data[key];
+      }
+    });
+    const aggregationKey = {
+      key: req.context.$apply.key.reduce((result, keyElement) => {
+        const type = elementType(keyElement, req);
+        let value = data[keyElement.name];
+        if (value !== undefined && value !== null) {
+          value = encodeURIKey(value);
+          if (DataTypeMap[type]) {
+            value = convertDataTypeToV2Uri(String(value), type).replace(/(.*)/s, DataTypeMap[type].v2);
+          }
+        }
+        result[keyElement.name] = value;
+        return result;
+      }, {}),
+      value: req.context.$apply.value.map((valueElement) => {
+        return valueElement.name;
+      }),
+    };
+    if (req.context.$apply.filter) {
+      aggregationKey.filter = encodeURIComponent(req.context.$apply.filter);
+    }
+    if (req.context.$apply.search) {
+      aggregationKey.search = encodeURIComponent(req.context.$apply.search);
+    }
+    data.ID__ = `aggregation'${JSON.stringify(aggregationKey)}'`;
+    data.__metadata.uri = entityUriKey(data.ID__, definition, req);
+    delete data.__metadata.etag;
+  }
+
+  function filterParameters(data, headers, definition, elements, body, req) {
+    if (
+      definition &&
+      definition.kind === "entity" &&
+      definition.params &&
+      req.context.parameters &&
+      req.context.parameters.kind === "Parameters"
+    ) {
+      Object.keys(elements).forEach((name) => {
+        if (!definition.params[name]) {
+          delete data[name];
+        }
+      });
+    }
+  }
+
+  function replaceConvertDataTypeToV2(value, type, definition) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => {
+        return replaceConvertDataTypeToV2(entry, type, definition);
+      });
+    }
+    value = convertDataTypeToV2(value, type, definition);
+    if (DataTypeMap[type]) {
+      if (!value.match(DataTypeMap[type].v2.replace("$1", ".*"))) {
+        value = DataTypeMap[type].v2.replace("$1", value);
+      }
+    }
+    return value;
+  }
+
+  function convertDataTypesToV2(data, headers, definition, elements, body, req) {
+    Object.keys(data).forEach((key) => {
+      if (data[key] === null) {
+        return;
+      }
+      const element = elements[key];
+      if (!element) {
+        return;
+      }
+      data[key] = convertDataTypeToV2(data[key], elementType(element, req), definition);
+    });
+  }
+
+  function convertDataTypeToV2(value, type, definition) {
+    if (value === null || value === undefined) {
+      return value;
+    }
+    if (Array.isArray(value)) {
+      return value.map((entry) => {
+        return convertDataTypeToV2(entry, type, definition);
+      });
+    }
+    if (["cds.Decimal", "cds.DecimalFloat", "cds.Double", "cds.Integer64"].includes(type)) {
+      value = `${value}`;
+    } else if (!isoDate && !definition["@cov2ap.isoDate"] && ["cds.Date"].includes(type)) {
+      value = `/Date(${new Date(value).getTime()})/`;
+    } else if (!isoTime && !definition["@cov2ap.isoTime"] && ["cds.Time"].includes(type)) {
+      value = convertToDayTimeDuration(value);
+    } else if (
+      !isoDateTime &&
+      !definition["@cov2ap.isoDateTime"] &&
+      !isoDateTimeOffset &&
+      !definition["@cov2ap.isoDateTimeOffset"] &&
+      ["cds.DateTime"].includes(type)
+    ) {
+      value = `/Date(${new Date(value).getTime()}+0000)/`; // always UTC
+    } else if (
+      !isoTimestamp &&
+      !definition["@cov2ap.isoTimestamp"] &&
+      !isoDateTimeOffset &&
+      !definition["@cov2ap.isoDateTimeOffset"] &&
+      ["cds.Timestamp"].includes(type)
+    ) {
+      value = `/Date(${new Date(value).getTime()}+0000)/`; // always UTC
+    }
+    return value;
+  }
+
+  function convertDataTypeToV2Uri(value, type) {
+    if (["cds.Date"].includes(type)) {
+      value = `${value}T00:00:00`;
+    } else if (["cds.Time"].includes(type)) {
+      value = convertToDayTimeDuration(value);
+    }
+    return value;
+  }
+
+  function convertToDayTimeDuration(value) {
+    const timeParts = value.split(":");
+    return `PT${timeParts[0] || "00"}H${timeParts[1] || "00"}M${timeParts[2] || "00"}S`;
+  }
+
+  function addResultsNesting(data, headers, definition, elements, root, req) {
+    if (!returnCollectionNested) {
+      return;
+    }
+    Object.keys(data).forEach((key) => {
+      const element = elements[key];
+      if (!element) {
+        return;
+      }
+      if (element.cardinality && element.cardinality.max === "*") {
+        data[key] = {
+          results: data[key],
+        };
+      }
+    });
+  }
+
+  function addDeferreds(data, headers, definition, elements, root, req) {
+    if (definition.kind !== "entity" || req.context.$apply) {
+      return;
+    }
+    const _entityUri = entityUri(data, definition, elements, req);
+    for (let key of structureKeys(elements)) {
+      const element = elements[key];
+      const type = elementType(element, req);
+      if (element && (type === "cds.Composition" || type === "cds.Association")) {
+        if (data[key] === undefined) {
+          if (fixDraftRequests && req.context.expandSiblingEntity && key === "SiblingEntity") {
+            data[key] = null;
+          } else {
+            data[key] = {
+              __deferred: {
+                uri: `${_entityUri}/${key}`,
+              },
+            };
+          }
+        }
+      }
+    }
+    if (definition.kind === "entity" && definition.params && req.context.parameters) {
+      if (req.context.parameters.kind === "Parameters") {
+        data.Set = {
+          __deferred: {
+            uri: `${_entityUri}/Set`,
+          },
+        };
+      } else if (req.context.parameters.kind === "Set") {
+        data.Parameters = {
+          __deferred: {
+            uri: `${_entityUri}/Parameters`,
+          },
+        };
+      }
+    }
+  }
+
+  function rootUri(req) {
+    const protocol = req.header("x-forwarded-proto") || req.protocol || "http";
+    const host =
+      req.header("x-forwarded-host") ||
+      req.headers.host ||
+      `${req.hostname || DefaultHost}:${req.socket.address().port || DefaultPort}`;
+    return `${protocol}://${host}`.replace(/^http:\/\/127.0.0.1/, `http://${DefaultHost}`);
+  }
+
+  function serviceUri(req) {
+    if (req.context.serviceUri) {
+      return req.context.serviceUri;
+    }
+    let serviceUri = rootUri(req);
+    if (req.header("x-forwarded-path") === undefined) {
+      serviceUri += `${sourcePath}/${req.servicePath}`;
+    } else {
+      const path = stripSlashes(URL.parse(req.header("x-forwarded-path") || "").pathname || "");
+      let resourceStartPath = "";
+      const definition = req.context.requestDefinition;
+      if (definition) {
+        if (definition.kind === "entity") {
+          resourceStartPath = localEntityName(definition, req);
+        } else if (definition.kind === "function" || definition.kind === "action") {
+          resourceStartPath = localEntityName(definition.parent || definition, req);
+        }
+      }
+      const parts = [];
+      path.split("/").some((part) => {
+        if (
+          part === resourceStartPath ||
+          part.startsWith(`${resourceStartPath}(`) ||
+          part.startsWith(`${resourceStartPath}?`) ||
+          part === "$batch" ||
+          part.startsWith("$batch?")
+        ) {
+          return true;
+        }
+        parts.push(part);
+        return false;
+      });
+      if (parts.length > 0) {
+        serviceUri += `/${parts.join("/")}`;
+      }
+    }
+    req.context.serviceUri = serviceUri.endsWith("/") ? serviceUri : `${serviceUri}/`;
+    return req.context.serviceUri;
+  }
+
+  function entityUriCollection(entity, req) {
+    return `${serviceUri(req)}${localEntityName(entity, req)}`;
+  }
+
+  function entityUriKey(key, entity, req) {
+    return `${entityUriCollection(entity, req)}(${key})`;
+  }
+
+  function entityUri(data, entity, elements, req) {
+    return entityUriKey(entityKey(data, entity, elements, req), entity, req);
+  }
+
+  function entityKey(data, entity, elements, req) {
+    if (entity.kind === "entity" && entity.params && req.context.parameters) {
+      return entityKeyParameters(data, entity, elements, req);
+    }
+    const keyElements = structureKeys(definitionKeys(entity)).reduce((keys, key) => {
+      const element = elements[key];
+      const type = elementType(element, req);
+      if (!(type === "cds.Composition" || type === "cds.Association")) {
+        keys.push(element);
+      }
+      return keys;
+    }, []);
+    return keyElements
+      .map((keyElement) => {
+        const type = elementType(keyElement, req);
+        let value = data[keyElement.name];
+        if (value !== undefined && value !== null) {
+          value = encodeURIKey(value);
+          if (DataTypeMap[type]) {
+            value = convertDataTypeToV2Uri(String(value), type).replace(/(.*)/s, DataTypeMap[type].v2);
+          }
+        }
+        if (keyElements.length === 1) {
+          return `${value}`;
+        } else {
+          return `${keyElement.name}=${value}`;
+        }
+      })
+      .join(",");
+  }
+
+  function entityKeyParameters(data, entity, elements, req) {
+    const keys = definitionKeys(entity);
+    const keyElements = [];
+    Object.keys(req.context.parameters.values).forEach((param) => {
+      keyElements.push(entity.params[param]);
+    });
+    if (req.context.parameters.kind === "Set") {
+      Object.keys(req.context.parameters.keys).forEach((key) => {
+        keyElements.push(keys[key]);
+      });
+      const columns = entity.query.SELECT.columns || [];
+      Object.keys(keys).forEach((key) => {
+        const param = columns.find((column) => column.as === key);
+        const paramName = (param ? param.ref.join("_") : "") || key;
+        if (!keyElements.find((keyElement) => keyElement.name === paramName)) {
+          keyElements.push(keys[key]);
+        }
+      });
+    }
+    data = { ...data, ...req.context.parameters.values, ...req.context.parameters.keys };
+    return keyElements
+      .map((keyElement) => {
+        const type = elementType(keyElement, req);
+        let value = data[keyElement.name];
+        if (value !== undefined && value !== null) {
+          value = encodeURIKey(value);
+          if (DataTypeMap[type]) {
+            value = convertDataTypeToV2Uri(String(value), type).replace(/(.*)/s, DataTypeMap[type].v2);
+          }
+        }
+        if (keyElements.length === 1) {
+          return `${value}`;
+        } else {
+          return `${keyElement.name}=${value}`;
+        }
+      })
+      .join(",");
+  }
+
+  function linkUri(req, params) {
+    const originalUrl = req.context.url.originalUrl;
+    Object.keys(params || {}).forEach((key) => {
+      const value = params[key];
+      if (Array.isArray(value)) {
+        params[key] = value.pop();
+      }
+      if (params[key] === undefined) {
+        delete params[key];
+      }
+    });
+    return (
+      serviceUri(req) +
+      decodeURIComponent(
+        URL.format({
+          ...originalUrl,
+          search: null,
+          pathname: originalUrl.contextPath,
+          query: {
+            ...originalUrl.query,
+            ...params,
+          },
+        })
+      )
+    );
+  }
+
+  function respond(req, res, statusCode, headers, body) {
+    if (!res.headersSent) {
+      if (!body || statusCode === 204) {
+        delete headers["content-length"];
+      }
+      Object.entries(headers).forEach(([name, value]) => {
+        res.setHeader(name, value);
+      });
+      res.status(statusCode);
+      if (body && statusCode !== 204) {
+        res.write(body);
+      }
+      res.end();
+
+      // Trace
+      traceResponse(req, "Response", res.statusCode, res.statusMessage, headers, body);
+    }
+  }
+
+  function normalizeContentType(headers) {
+    let contentType = headers["content-type"];
+    if (contentType) {
+      contentType = contentType.trim();
+      if (isApplicationJSON(contentType)) {
+        contentType = contentType
+          .split(";")
+          .filter((part) => {
+            return !part.startsWith("odata.");
+          })
+          .join(";");
+      }
+      headers["content-type"] = contentType;
+    }
+    return contentType;
+  }
+
+  function normalizeBody(body) {
+    if (typeof body === "string" || Buffer.isBuffer(body)) {
+      return body;
+    }
+    if (typeof body === "object") {
+      return JSON.stringify(body);
+    }
+    return String(body);
+  }
+
+  function propagateHeaders(req, addHeaders = {}) {
+    const headers = Object.assign({}, req.headers, addHeaders);
+    headers["x-request-id"] = req.contextId;
+    headers["x-correlation-id"] = req.contextId;
+    headers["x-correlationid"] = req.contextId;
+    delete headers.host;
+    return headers;
+  }
+
+  function enrichApplicationJSON(contentType) {
+    const [key] = IEEE754Compatible.split("=");
+    if (!contentType.includes(key)) {
+      contentType += ";" + IEEE754Compatible;
+    }
+    return contentType;
+  }
+
+  function isApplicationJSON(contentType) {
+    return contentType && contentType.startsWith("application/json");
+  }
+
+  function isPlainText(contentType) {
+    return contentType && contentType.startsWith("text/plain");
+  }
+
+  function isXML(contentType) {
+    return (
+      contentType &&
+      (contentType.startsWith("application/xml") ||
+        contentType.startsWith("application/atomsvc+xml") ||
+        contentType.startsWith("text/xml") ||
+        contentType.startsWith("text/html"))
+    );
+  }
+
+  function isMultipartMixed(contentType) {
+    return contentType && contentType.replace(/\s/g, "").startsWith("multipart/mixed;boundary=");
+  }
+
+  function isMultipartFormData(contentType) {
+    return contentType && contentType.replace(/\s/g, "").startsWith("multipart/form-data;boundary=");
+  }
+
+  function encodeURIKey(value) {
+    return encodeURIComponent(value).replace(/[/]/g, "%2F").replace(/'/g, "''").replace(/%3A/g, ":");
+  }
+
+  function decodeURIKey(value) {
+    return decodeURIComponent(value).replace(/%2F/g, "/");
+  }
+
+  function targetUrl(req) {
+    // Non-batch scenario only
+    let path = req.originalUrl;
+    Object.entries(pathRewrite).forEach(([key, value]) => {
+      path = path.replace(new RegExp(key, "g"), value);
+    });
+    return path;
+  }
+
+  function lookupReturnDefinition(returns, req) {
+    returns = (returns && returns.items) || returns;
+    if (returns && returns.type) {
+      const definition = lookupDefinition(returns.type, req);
+      return definition || lookupReturnPrimitiveDefinition(returns);
+    }
+    return returns;
+  }
+
+  function lookupReturnPrimitiveDefinition(returns) {
+    returns = (returns && returns.items) || returns;
+    return {
+      name: lookupODataType(returns && returns.type),
+      elements: {
+        value: returns,
+      },
+    };
+  }
+
+  function lookupODataType(type) {
+    const odataType = Object.keys(DataTypeOData).find((key) => {
+      return DataTypeOData[key] === type;
+    });
+    if (odataType && odataType.startsWith("_")) {
+      return odataType.substr(1);
+    }
+    return odataType;
+  }
+
+  function structureKeys(structure) {
+    const keys = [];
+    for (const key in structure || {}) {
+      keys.push(key);
+    }
+    return keys;
+  }
+
+  function definitionElements(definition) {
+    if (definition && definition.elements) {
+      return structureKeys(definition.elements).reduce((elements, key) => {
+        const element = definition.elements[key];
+        if (element["@cds.api.ignore"]) {
+          return elements;
+        }
+        elements[key] = element;
+        if (
+          (element.type === "cds.Composition" || element.type === "cds.Association") &&
+          element.keys &&
+          element._target
+        ) {
+          element.keys.forEach((key) => {
+            const targetKey = key.ref[0];
+            const foreignKey = `${element.name}_${targetKey}`;
+            if (!elements[foreignKey]) {
+              elements[foreignKey] = {
+                key: element.key,
+                type: element._target.elements[targetKey].type,
+                name: foreignKey,
+                parent: element.parent,
+                kind: element.kind,
+              };
+            }
+          });
+        }
+        return elements;
+      }, {});
+    }
+    return {};
+  }
+
+  function definitionKeys(definition) {
+    const elements = definitionElements(definition);
+    return structureKeys(elements).reduce((keys, key) => {
+      if (elements[key].key) {
+        keys[key] = elements[key];
+      }
+      return keys;
+    }, {});
+  }
+
+  function elementType(element, req) {
+    let type;
+    if (element) {
+      type = element.type;
+      if (element["@odata.Type"] || element["@odata.type"]) {
+        const odataType = localName(element["@odata.Type"] || element["@odata.type"]);
+        if (odataType && DataTypeOData[odataType]) {
+          type = DataTypeOData[odataType];
+        }
+      }
+      if (!type && element.items && element.items.type) {
+        type = element.items.type;
+      }
+    }
+    return baseElementType(type, req.csn);
+  }
+
+  function baseElementType(type, csn) {
+    if (type && csn.definitions[type]) {
+      type = csn.definitions[type].type;
+      type = baseElementType(type, csn);
+    }
+    return type;
+  }
+
+  function findElementByType(elements, type, req) {
+    return structureKeys(elements)
+      .filter((key) => {
+        return !(elements[key].type === "cds.Composition" && elements[key].type === "cds.Association");
+      })
+      .find((key) => {
+        const element = elements[key];
+        return element && elementType(element, req) === type;
+      });
+  }
+
+  function findElementByAnnotation(elements, annotation) {
+    return structureKeys(elements)
+      .filter((key) => {
+        return !(elements[key].type === "cds.Composition" && elements[key].type === "cds.Association");
+      })
+      .find((key) => {
+        const element = elements[key];
+        return element && !!element[annotation];
+      });
+  }
+
+  function findElementValueByAnnotation(elements, annotation) {
+    const elementName = findElementByAnnotation(elements, annotation);
+    if (elementName) {
+      const elementValue = elements[elementName][annotation];
+      if (elementValue) {
+        return elementValue["="] || elementValue;
+      }
+    }
+    return undefined;
+  }
+
+  function findEndingElementName(elements, url) {
+    return structureKeys(elements)
+      .filter((key) => {
+        return !(elements[key].type === "cds.Composition" && elements[key].type === "cds.Association");
+      })
+      .find((key) => {
+        const element = elements[key];
+        return url.contextPath.endsWith(`/${element.name}`);
+      });
+  }
+
+  function determineLocale(req) {
+    let locale = cds.env.i18n && cds.env.i18n.default_language;
+    try {
+      locale = require("../../req/locale")(req);
+    } catch {
+      try {
+        // CDS 3
+        locale = require("@sap/cds-runtime/lib/cds-services/adapter/utils/locale")({ req }); // eslint-disable-line cds/no-missing-dependencies
+      } catch {
+        // Default
+      }
+    }
+    if (locale && locale.length >= 2) {
+      locale = locale.substr(0, 2).toLowerCase() + locale.slice(2);
+    }
+    return locale || "en";
+  }
+
+  const ensureArray = (value) => {
+    if (!value) {
+      return [];
+    }
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (typeof value === "string") {
+      return value.split(",");
+    }
+    if (typeof value === "object") {
+      return Object.keys(value)
+        .filter((k) => value[k])
+        .sort();
+    }
+    return [];
+  };
+
+  function decodeBase64(b64String) {
+    return Buffer.from(b64String, "base64").toString();
+  }
+
+  function decodeJwtTokenBody(token) {
+    const parts = token.split(".");
+    if (parts.length > 1) {
+      return JSON.parse(decodeBase64(parts[1]));
+    }
+    throw new Error("Invalid JWT token");
+  }
+
+  function setContentLength(headers, body) {
+    if (body && !(headers["transfer-encoding"] || "").includes("chunked")) {
+      headers["content-length"] = Buffer.byteLength(body);
+    } else {
+      delete headers["content-length"];
+    }
+  }
+
+  function processMultipartMixed(
+    req,
+    multiPartBody,
+    contentType,
+    urlProcessor,
+    bodyHeadersProcessor,
+    contentIdOrder = [],
+    direction
+  ) {
+    let maxContentId = 1;
+
+    function nextContentID() {
+      return "cov2ap_" + String(maxContentId++);
+    }
+
+    if (!multiPartBody || !(typeof multiPartBody === "string")) {
+      const error = new Error("Invalid multipart body");
+      error.statusCode = 400;
+      throw error;
+    }
+
+    if (!contentType || !(typeof contentType === "string")) {
+      const error = new Error("Invalid content type");
+      error.statusCode = 400;
+      throw error;
+    }
+
+    const match = contentType.replace(/\s/g, "").match(/^multipart\/mixed;boundary=([^;]*)/i);
+    let boundary = match && match.pop();
+    if (!boundary) {
+      return multiPartBody;
+    }
+    let boundaryChangeSet = "";
+    let urlAfterBlank = false;
+    let bodyAfterBlank = false;
+    let previousLineIsBlank = false;
+    let index = 0;
+    let statusCode;
+    let contentId;
+    let contentIdMisplaced = false;
+    let contentTransferEncoding;
+    let body = "";
+    let headers = {};
+    let method = "";
+    let url = "";
+    const parts = multiPartBody.split("\r\n");
+    const newParts = [];
+    parts.forEach((part) => {
+      const match = part.replace(/\s/g, "").match(/^content-type:multipart\/mixed;boundary=(.*)$/i);
+      if (match) {
+        boundaryChangeSet = match.pop();
+      }
+      if (part.startsWith(`--${boundary}`) || (boundaryChangeSet && part.startsWith(`--${boundaryChangeSet}`))) {
+        // Body & Headers
+        if (bodyAfterBlank) {
+          if (bodyHeadersProcessor) {
+            try {
+              const contentType = normalizeContentType(headers);
+              if (isApplicationJSON(contentType)) {
+                body = (body && JSON.parse(body)) || {};
+              }
+              const result = bodyHeadersProcessor({
+                index,
+                statusCode,
+                contentType,
+                body,
+                headers,
+                method,
+                url,
+                contentId,
+              });
+              body = (result && result.body) || body;
+              headers = (result && result.headers) || headers;
+            } catch (err) {
+              // Error
+              logError(req, "Batch", err);
+            }
+          }
+          if (boundaryChangeSet) {
+            // Inject mandatory content-id for changesets
+            const addContentIdHeader = contentId === undefined || contentIdMisplaced;
+            if (contentId === undefined && direction === ProcessingDirection.Request) {
+              contentId = nextContentID();
+            }
+            if (contentId !== undefined) {
+              if (direction === ProcessingDirection.Request || !contentId.startsWith("cov2ap_")) {
+                if (addContentIdHeader) {
+                  // Add content-id to headers of changeset (before url = -3)
+                  newParts.splice(-3, 0, `content-id: ${contentId}`);
+                }
+                headers["content-id"] = contentId;
+              }
+              contentIdOrder.push(contentId);
+            }
+          }
+          // Inject mandatory content-transfer-encoding
+          if (!contentTransferEncoding) {
+            contentTransferEncoding = "binary";
+            // Add content-transfer-encoding to headers (before url = -3)
+            newParts.splice(-3, 0, `content-transfer-encoding: ${contentTransferEncoding}`);
+          }
+          Object.entries(headers).forEach(([name, value]) => {
+            newParts.splice(-1, 0, `${name}: ${value}`);
+          });
+          newParts.push(body);
+          statusCode = undefined;
+          contentId = undefined;
+          contentIdMisplaced = false;
+          contentTransferEncoding = undefined;
+          body = "";
+          headers = {};
+          url = "";
+          index++;
+        }
+        urlAfterBlank = true;
+        bodyAfterBlank = false;
+        newParts.push(part);
+        if (boundaryChangeSet && part === `--${boundaryChangeSet}--`) {
+          boundaryChangeSet = "";
+        }
+      } else if (urlAfterBlank && previousLineIsBlank) {
+        urlAfterBlank = false;
+        bodyAfterBlank = true;
+        // Url
+        const urlParts = part.split(" ");
+        let partMethod = urlParts[0];
+        let partUrl = urlParts.slice(1, -1).join(" ");
+        let partProtocol = urlParts.pop();
+        if (urlProcessor) {
+          const result = urlProcessor({ method: partMethod, url: partUrl });
+          if (result) {
+            partMethod = result.method;
+            partUrl = result.url;
+            part = [partMethod, partUrl, partProtocol].join(" ");
+          }
+        }
+        method = partMethod;
+        url = partUrl;
+
+        newParts.push(part);
+        if (part.startsWith("HTTP/")) {
+          const statusCodeMatch = part.match(/^HTTP\/[\d.]+\s+(\d{3})\s.*$/i);
+          if (statusCodeMatch) {
+            statusCode = parseInt(statusCodeMatch.pop());
+          }
+        }
+      } else if (bodyAfterBlank && (previousLineIsBlank || body !== "")) {
+        body = body ? `${body}\r\n${part}` : part;
+      } else if (part !== "") {
+        const partIsContentId = part.toLowerCase().startsWith("content-id:");
+        if (partIsContentId) {
+          const colonIndex = part.indexOf(":");
+          if (colonIndex !== -1) {
+            contentId = part.substr(colonIndex + 1).trim();
+            contentIdMisplaced = !!bodyAfterBlank;
+          }
+        }
+        const partContentTransferEncoding = part.toLowerCase().startsWith("content-transfer-encoding:");
+        if (partContentTransferEncoding && !bodyAfterBlank) {
+          const colonIndex = part.indexOf(":");
+          if (colonIndex !== -1) {
+            contentTransferEncoding = part.substr(colonIndex + 1).trim();
+          }
+        }
+        if (!bodyAfterBlank) {
+          if (!(direction === ProcessingDirection.Response && partIsContentId && contentId.startsWith("cov2ap_"))) {
+            newParts.push(part);
+          }
+        } else {
+          let colonIndex = part.indexOf(":");
+          if (colonIndex !== -1) {
+            headers[part.substr(0, colonIndex).toLowerCase()] = part.substr(colonIndex + 1).trim();
+          }
+        }
+      } else {
+        newParts.push(part);
+      }
+      previousLineIsBlank = part === "";
+    });
+    return newParts.join("\r\n");
+  }
+
+  function traceRequest(req, name, method, url, headers, body) {
+    if (LOG._debug) {
+      const _url = url || "";
+      const _headers = JSON.stringify(headers || {});
+      const _body = typeof body === "string" ? body : body ? JSON.stringify(body) : "";
+      trace(req, name, `${method} ${_url}`, _headers && "Headers:", _headers, _body && "Body:", _body);
+    }
+  }
+
+  function traceResponse(req, name, statusCode, statusMessage, headers, body) {
+    if (LOG._debug) {
+      const _headers = JSON.stringify(headers || {});
+      const _body = typeof body === "string" ? body : body ? JSON.stringify(body) : "";
+      trace(
+        req,
+        name,
+        `${statusCode || ""} ${statusMessage || ""}`,
+        _headers && "Headers:",
+        _headers,
+        _body && "Body:",
+        _body
+      );
+    }
+  }
+
+  function trace(req, name, ...lines) {
+    if (LOG._debug) {
+      initCDSContext(req);
+      LOG.debug(name, lines.filter((line) => !!line).join("\n"));
+    }
+  }
+
+  function logError(req, name, error) {
+    if (LOG._error) {
+      initCDSContext(req);
+      LOG.error(name, error);
+    }
+  }
+
+  function logWarning(req, name, message, info) {
+    if (LOG._warn) {
+      initCDSContext(req);
+      LOG.warn(name, message, info);
+    }
+  }
+
+  function initCDSContext(req) {
+    cds.context = cds.context || {
+      id: req.contextId,
+      tenant: req.tenant,
+      user: req.user,
+      _: { req, res: req.res },
+    };
+  }
+
+  return router;
+}
+
+module.exports = cov2ap;