@sap/cds 5.4.6 → 5.5.0

package/libx/_runtime/odata/readToCqn.js

@@ -1,93 +1,123 @@
 const cds = require('../cds')
+const { SELECT } = cds.ql
+
+const getError = require('../common/error')
 const { findCsnTargetFor } = require('../common/utils/csn')
-// REVISIT: should be cds.ql
-const { SELECT } = require('../cds-services/statements')
+const { getAllKeys } = require('../cds-services/adapter/odata-v4/odata-to-cqn/utils')
 const rewriteAsterisk = require('../common/utils/rewriteAsterisk')
-
 const { getMaxPageSize } = require('../common/utils/page')
 
-const _isEntityWithKeys = (entity, ref) => {
-  if (!ref || !ref.id || !ref.where) return
-  const keys = ref.where.reduce((res, part) => {
-    if (Array.isArray(part.ref)) res.push(part.ref[0])
-    return res
-  }, [])
-  for (const key in entity.keys) {
-    if (entity.elements[key].target) continue
-    if (keys.indexOf(key) === -1) return
-    keys.splice(keys.indexOf(key))
+const _hasAllEntityKeysInWhere = (keys, where) => {
+  if (!(where && keys && keys.length)) return
+  keys = keys.map(key => (Array.isArray(key) ? key.join('_') : key))
+  for (const part of where) {
+    if (part.ref && keys.indexOf(part.ref.join('_')) > -1) {
+      keys.splice(keys.indexOf(part.ref.join('_')))
+    }
   }
+
   return keys.length === 0
 }
 
-const _isCollection = (ref, root, model) =>
-  ref.length > 1
-    ? ref.slice(1).reduce((csn, _ref, i, arr) => {
-        if (!csn) return false
-        const seg = _ref.id || _ref
-        let target = csn.elements && csn.elements[seg]
-        if (!target) {
-          if (csn.target) target = model.definitions[csn.target].elements[seg]
-          else if (!csn.items && csn._isStructured) {
-            // REVISIT: this is not tested with x4!!!
-            if (csn.elements) target = csn.elements[seg]
-            else if (csn.type) target = model.definitions[csn.type].elements[seg]
-          }
-        }
-        if (i === arr.length - 1) {
-          if (target && target.target) return !_isEntityWithKeys(model.definitions[target.target], _ref)
-          if (target && target.items) return true
-        } else return target
-      }, root)
-    : !_isEntityWithKeys(root, ref[0])
+const _setLimits = (cqn, parsed, target) => {
+  // adjust SELECT.limit based on @cds.query.limit annotations
+  const rows = parsed.SELECT.limit.rows ? parsed.SELECT.limit.rows.val : Number.MAX_SAFE_INTEGER
+  const offset = parsed.SELECT.limit.offset ? parsed.SELECT.limit.offset.val : 0
+  cqn.limit(Math.min(rows, getMaxPageSize(target)), offset)
+}
 
-/*
- * uses new odata2cqn
- */
-const _newReadToCQN = ({ model, namespace }, target, req) => {
-  const odata = !!req.getUrlObject
+const _setRootInFrom = (cqn, target, model, namespace) => {
+  const root = _findRoot(cqn, target, model, namespace)
+  const from = cqn.SELECT.from
+  if (from.ref[0].id) from.ref[0].id = root.name
+  else from.ref[0] = root.name
+  return cqn
+}
 
-  const url = odata ? req.getUrlObject().path : req.url
+const _findRoot = (cqn, target, model, namespace) => {
+  const parsedTargetName = cqn.SELECT.from.ref[0].id || cqn.SELECT.from.ref[0]
+  return target.name === parsedTargetName ? target : findCsnTargetFor(parsedTargetName, model, namespace)
+}
 
-  const parsed = cds.odata.parse.url(url)
+const _resolveRef = (ref, model, parent) => {
+  ref = ref.id || ref
+  const element = parent && parent.elements && parent.elements[ref]
+  let target = element || parent || model.definitions[ref]
+  let aspect
+  if (target && !target.elements) {
+    if (target.target) {
+      if (target.targetAspect) aspect = model.definitions[target.targetAspect]
+      target = model.definitions[target.target]
+    } else if (target.kind === 'type') {
+      target = model.definitions[target.type]
+    }
+  }
+  const keys = getAllKeys(aspect || target, false)
+  return { target, keys, element }
+}
 
-  const parsedTargetName = parsed.SELECT.from.ref[0].id || parsed.SELECT.from.ref[0]
-  let root = target
-  if (parsedTargetName !== target.name) {
-    root = findCsnTargetFor(parsedTargetName, model, namespace)
-    if (parsed.SELECT.from.ref[0].id) {
-      parsed.SELECT.from.ref[0].id = root.name
-    } else {
-      parsed.SELECT.from.ref[0] = root.name
+const _resolveStructKeys = (where, keys) => {
+  for (const el of where) {
+    if (!el.ref) continue
+    const keyIdx = keys.findIndex(key => Array.isArray(key) && key[key.length - 1] === el.ref[0])
+    if (keyIdx > -1) {
+      el.ref = [keys[keyIdx].join('_')]
+      keys.splice(keyIdx, 1)
     }
   }
-  const whereKeys = parsed.SELECT.from.ref[0].where
-  if (whereKeys && whereKeys.length === 1) {
-    whereKeys.push('=', whereKeys[0])
-    for (const key in root.keys) {
-      whereKeys.splice(0, 1, { ref: [key] })
+}
+
+const _postProcess = (cqn, target, model, namespace) => {
+  _setRootInFrom(cqn, target, model, namespace)
+  let prev
+  for (let i = 0; i < cqn.SELECT.from.ref.length; i++) {
+    const ref = cqn.SELECT.from.ref[i]
+    const { target, keys, element } = _resolveRef(ref, model, prev)
+    if (ref.where) {
+      // cases like `GET /Foo(1)/bar(2)` => `where` contains single `val`s
+      if (ref.where.length === 1 && keys.length === 1) {
+        ref.where = [{ ref: [Array.isArray(keys[0]) ? keys[0].join('_') : keys[0]] }, '=', ref.where[0]]
+      } else {
+        _resolveStructKeys(ref.where, keys)
+      }
     }
+    // $value never comes, $count is 2many, $ref is to be checked
+    if (i === cqn.SELECT.from.ref.length - 1) {
+      if (target && !target.elements) delete cqn.SELECT.columns
+      if ((element && element.is2one) || (target && target._isSingleton) || _hasAllEntityKeysInWhere(keys, ref.where)) {
+        cqn.SELECT.one = true
+      }
+    }
+    prev = target
+  }
+  return cqn
+}
+
+/*
+ * uses new odata2cqn
+ */
+const _newReadToCQN = ({ model, namespace }, target, req) => {
+  let parsed
+
+  try {
+    parsed = cds.odata.parse.url(req.url || req._inRequestUrl)
+  } catch (err) {
+    throw getError(400, err.message)
   }
 
-  const cqn = SELECT.from(target.name)
+  _postProcess(parsed, target, model, namespace)
 
-  cqn.SELECT.from = parsed.SELECT.from
-  if (parsed.SELECT.columns) cqn.SELECT.columns = parsed.SELECT.columns
+  const cqn = SELECT.from(parsed.SELECT.from, parsed.SELECT.columns)
   if (parsed.SELECT.search) cqn.SELECT.search = parsed.SELECT.search
   if (parsed.SELECT.where) cqn.SELECT.where = parsed.SELECT.where
   if (parsed.SELECT.orderBy) cqn.SELECT.orderBy = parsed.SELECT.orderBy
   if (parsed.SELECT.groupBy) cqn.SELECT.groupBy = parsed.SELECT.groupBy
   if (parsed.SELECT.count) cqn.SELECT.count = parsed.SELECT.count
-
-  if (!_isCollection(parsed.SELECT.from.ref, root, model)) {
-    cqn.SELECT.one = true
+  if (parsed.SELECT.one) {
+    cqn.SELECT.one = parsed.SELECT.one
   } else if (parsed.SELECT.limit) {
-    // adjust SELECT.limit based on @cds.query.limit annotations
-    const rows = parsed.SELECT.limit.rows ? parsed.SELECT.limit.rows.val : Number.MAX_SAFE_INTEGER
-    const offset = parsed.SELECT.limit.offset ? parsed.SELECT.limit.offset.val : 0
-    cqn.limit(Math.min(rows, getMaxPageSize(target)), offset)
+    _setLimits(cqn, parsed, target, model)
   }
-
   if (!cds.env.features.rest_new_parser) {
     // REVISIT not needed for rest parser?
     rewriteAsterisk({ query: cqn, target })

package/libx/_runtime/remote/Service.js

@@ -9,15 +9,12 @@ if (!LOG._debug) {
   sdkUtils.setGlobalLogLevel('error')
 }
 
-const { resolveView, getTransition } = require('../common/utils/resolveView')
-const { getKind, run, getDestination, getAdditionalOptions, getReqOptions, postProcess } = require('./utils/client')
+const { resolveView, getTransition, restoreLink, findQueryTarget } = require('../common/utils/resolveView')
+const { postProcess } = require('../common/utils/postProcessing')
+const { getKind, run, getDestination, getAdditionalOptions, getReqOptions } = require('./utils/client')
 const { formatVal } = require('../odata/cqn2odata')
 
-const _checkProduction = destination => {
-  if (!destination && process.env.NODE_ENV === 'production') {
-    throw new Error('In production mode it is required to set `options.destination`')
-  }
-}
+const _isSimpleCqnQuery = q => typeof q === 'object' && q !== null && !Array.isArray(q) && Object.keys(q).length > 0
 
 const _setHeaders = (defaultHeaders, req) => {
   return Object.assign(
@@ -112,17 +109,30 @@ const _addHandlerActionFunction = (srv, def, target) => {
   }
 }
 
+const _selectOnlyWithAlias = q => {
+  return q && q.SELECT && !q.SELECT._transitions && q.SELECT.columns && q.SELECT.columns.some(c => c.as)
+}
+
+const resolvedTargetOfQuery = q => {
+  const transitions = (typeof q === 'object' && (q.SELECT || q.INSERT || q.UPDATE || q.DELETE)._transitions) || []
+  return transitions.length && [transitions.length - 1].target
+}
+
 class RemoteService extends cds.Service {
   init() {
-    this.destination = this.options.credentials && this.options.credentials.destination
-    this.requestTimeout = this.options.credentials && this.options.credentials.requestTimeout
-    if (this.requestTimeout === null || this.requestTimeout === undefined) this.requestTimeout = 60000
-    this.path = this.options.credentials && this.options.credentials.path
+    if (!this.options.credentials) {
+      throw new Error(`No credentials configured for "${this.name}".`)
+    }
+
     this.datasource = this.options.datasource
+    this.destination =
+      this.options.credentials.destination ||
+      getDestination((this.definition && this.definition.name) || this.datasource, this.options.credentials)
+    this.requestTimeout = this.options.credentials.requestTimeout
+    if (this.requestTimeout == null) this.requestTimeout = 60000
+    this.path = this.options.credentials.path
     this.kind = getKind(this.options) // TODO: Simplify
 
-    _checkProduction(this.destination)
-
     for (const each of this.entities) {
       for (const a in each.actions) {
         _addHandlerActionFunction(this, each.actions[a], each)
@@ -136,20 +146,63 @@ class RemoteService extends cds.Service {
     this.on('*', async (req, next) => {
       let { query } = req
       if (!query && !(typeof req.path === 'string')) return next()
-      if (typeof query === 'object' && this.model) query = resolveView(query, this.model, 'remote', true)
-      const transitions =
-        (typeof query === 'object' && (query.SELECT || query.INSERT || query.UPDATE || query.DELETE)._transitions) || []
-      const resolvedTarget =
-        (transitions.length && [transitions.length - 1].target) || getTransition(req.target, true).target
-      if (!this.destination) this.destination = getDestination(this.model, this.datasource, this.options)
+      if (cds.env.features.resolve_views === false && typeof query === 'object' && this.model) {
+        query = resolveView(query, this.model, this)
+      }
+
+      const resolvedTarget = resolvedTargetOfQuery(query) || getTransition(req.target, this).target
       const reqOptions = getReqOptions(req, query, this)
       reqOptions.headers = _setHeaders(reqOptions.headers, req)
       const additionalOptions = getAdditionalOptions(req, this.destination, this.kind, resolvedTarget)
 
-      const result = await run(reqOptions, additionalOptions)
-      return typeof query === 'object' ? postProcess(query, result) : result
+      // hidden compat flag in order to suppress logging response body of failed request
+      if (req._suppressRemoteResponseBody) {
+        additionalOptions.suppressRemoteResponseBody = req._suppressRemoteResponseBody
+      }
+
+      let result = await run(reqOptions, additionalOptions)
+
+      result =
+        typeof query === 'object' && query.SELECT && query.SELECT.one && Array.isArray(result) ? result[0] : result
+
+      return cds.env.features.resolve_views === false && typeof query === 'object' ? postProcess(query, result) : result
     })
   }
+
+  // Overload .handle in order to resolve projections up to a definition that is known by the remote service instance.
+  // Result is post processed according to the inverse projection in order to reflect the correct result of the original query.
+  async handle(req) {
+    // compat mode
+    if (req._resolved || cds.env.features.resolve_views === false) return super.handle(req)
+
+    if (req.target && req.target.name && this.definition && req.target.name.startsWith(this.definition.name + '.')) {
+      const result = await super.handle(req)
+      // only post process if alias was explicitely set in query
+      if (_selectOnlyWithAlias(req.query)) {
+        return postProcess(req.query, result, true)
+      }
+      return result
+    }
+
+    // req.query can be:
+    // - empty object in case of unbound action/function
+    // - undefined/null in case of plain string queries
+    if (_isSimpleCqnQuery(req.query) && this.model) {
+      const q = resolveView(req.query, this.model, this)
+      const t = findQueryTarget(q) || req.target
+
+      // compat
+      restoreLink(req)
+
+      // REVISIT: We need to provide target explicitly because it's cached already within ensure_target
+      const newReq = new cds.Request({ query: q, target: t, headers: req.headers, _resolved: true })
+      const result = await super.dispatch(newReq)
+
+      return postProcess(q, result, true)
+    }
+
+    return super.handle(req)
+  }
 }
 
 module.exports = RemoteService

package/libx/_runtime/remote/cqn2odata/index.js

@@ -1,6 +1,2 @@
 const cds = require('../../cds')
-
-module.exports = (cqn, type, model) => {
-  if (!cds.odata) cds.odata = require('../../odata')
-  return cds.odata.parse.cqn(cqn, type, model)
-}
+module.exports = cds.odata.urlify

package/libx/_runtime/remote/utils/client.js

@@ -1,7 +1,7 @@
 const cds = require('../../cds')
 const LOG = cds.log('remote')
+const cdsLocale = require('../../../../lib/req/locale.js')
 
-const { revertData } = require('../../common/utils/resolveView')
 const generateQuery = require('../cqn2odata')
 const { convertV2ResponseData } = require('./dataConversion')
 
@@ -26,27 +26,9 @@ const _executeHttpRequest = (...args) => {
   return _cloudSdkCore.executeHttpRequest(...args)
 }
 
-const findServiceName = (model, ds, options) => {
-  const modelServices = Object.values(model.services)
-
-  if (options.credentials && options.credentials.service) {
-    if (!modelServices.find(srv => srv.name === options.credentials.service)) {
-      throw new Error(`Service "${options.credentials.service}" not found in provided model`)
-    }
-
-    return options.credentials.service
-  }
-
-  return ds
-}
-
-const createDestinationObject = (name, credentials) => {
-  if (!credentials) {
-    throw new Error(`No credentials configured for "${name}"`)
-  }
-
+const getDestination = (name, credentials) => {
   if (!credentials.url) {
-    throw new Error(`No url configured in credentials for "${name}"`)
+    throw new Error(`"url" or "destination" property must be configured in "credentials" of "${name}".`)
   }
 
   return { name, ...credentials }
@@ -88,62 +70,6 @@ const formatPath = path => {
 
   return formattedPath
 }
-// creates a map with key "remote origin name" and value { as: "projection name"}
-// if it is an expand, it contains an additional property .expand with classic ref/as syntax
-// ref/as syntax is kept in order to reuse handleAliasInResult
-const _createAliasMap = columns => {
-  if (columns) {
-    let aliasMap
-    for (const col of columns) {
-      const processor = {}
-      if (col.as) {
-        processor.as = col.as
-        ;(aliasMap || (aliasMap = new Map())) && aliasMap.set(col.ref[col.ref.length - 1], processor)
-      }
-      if (col.expand) {
-        processor.expand = col.expand
-      }
-    }
-
-    return aliasMap
-  }
-}
-
-// Transforms the result of the remote service according to the provided aliases
-const handleAliasInResult = (columns, result) => {
-  const postProcessor = _createAliasMap(columns)
-  const resultArray = Array.isArray(result) ? result : [result]
-  if (postProcessor) {
-    for (const row of resultArray) {
-      // we need to use a cache because of cross renamings
-      // e. g. column a is renamed to b and column b is renamed to a
-      const tempCache = new Map()
-
-      for (const col in row) {
-        const processor = postProcessor.get(col)
-        if (processor && processor.as !== col) {
-          // if a value for the alias is already present, add it to the cache
-          if (row[processor.as]) {
-            tempCache.set(processor.as, row[processor.as])
-          }
-
-          // get the value from cache if present
-          row[processor.as] = tempCache.get(col) || row[col]
-
-          // if it was not overridden because of a renaming,
-          // delete it from the row
-          if (!tempCache.has(processor.as)) {
-            delete row[col]
-          }
-        }
-
-        if (processor && processor.expand) {
-          handleAliasInResult(processor.expand, row[processor.as || col])
-        }
-      }
-    }
-  }
-}
 
 function _defineProperty(obj, property, value) {
   const props = {}
@@ -202,7 +128,7 @@ const _purgeODataV4 = data => {
 const TYPES_TO_REMOVE = { function: 1, object: 1 }
 const PROPS_TO_IGNORE = { cause: 1, name: 1 }
 
-const _getSanitizedError = (e, reqOptions) => {
+const _getSanitizedError = (e, reqOptions, suppressRemoteResponseBody) => {
   e.request = {
     method: reqOptions.method,
     url: e.config ? e.config.baseURL + e.config.url : reqOptions.url,
@@ -215,7 +141,9 @@ const _getSanitizedError = (e, reqOptions) => {
       statusText: e.response.statusText,
       headers: e.response.headers
     }
-    if (e.response.data && e.response.data.error) response.body = e.response.data
+    if (e.response.data && !suppressRemoteResponseBody) {
+      response.body = e.response.data
+    }
     e.response = response
   }
 
@@ -247,7 +175,7 @@ const _getSanitizedError = (e, reqOptions) => {
   return e
 }
 
-const run = async (reqOptions, { destination, jwt, kind, resolvedTarget }) => {
+const run = async (reqOptions, { destination, jwt, kind, resolvedTarget, suppressRemoteResponseBody }) => {
   const dest = typeof destination === 'string' ? { destinationName: destination, jwt } : destination
 
   let response
@@ -257,7 +185,7 @@ const run = async (reqOptions, { destination, jwt, kind, resolvedTarget }) => {
     // > axios received status >= 400 -> gateway error
     e.message = e.message ? 'Error during request to remote service: ' + e.message : 'Request to remote service failed.'
 
-    const sanitizedError = _getSanitizedError(e, reqOptions)
+    const sanitizedError = _getSanitizedError(e, reqOptions, suppressRemoteResponseBody)
 
     LOG._warn && LOG.warn(sanitizedError)
 
@@ -278,7 +206,7 @@ const run = async (reqOptions, { destination, jwt, kind, resolvedTarget }) => {
     const e = new Error("Received content-type 'text/html' which is not part of accepted content types")
     e.response = response
 
-    const sanitizedError = _getSanitizedError(e, reqOptions)
+    const sanitizedError = _getSanitizedError(e, reqOptions, suppressRemoteResponseBody)
 
     LOG._warn && LOG.warn(sanitizedError)
 
@@ -353,6 +281,11 @@ const _pathToReqOptions = (method, path, data) => {
   return reqOptions
 }
 
+const _hasHeader = (headers, header) =>
+  Object.keys(headers || [])
+    .map(k => k.toLowerCase())
+    .includes(header)
+
 const getReqOptions = (req, query, service) => {
   const reqOptions =
     typeof query === 'object'
@@ -364,11 +297,19 @@ const getReqOptions = (req, query, service) => {
   reqOptions.headers = { accept: 'application/json,text/plain' }
   reqOptions.timeout = service.requestTimeout
 
+  if (!_hasHeader(req.headers, 'accept-language')) {
+    // Forward the locale properties from the original request (including region variants or weight factors),
+    // if not given, it's taken from the user's locale (normalized and simplified)
+    const locale =
+      (req.context && req.context._ && req.context._.req && cdsLocale.from_req(req.context._.req)) ||
+      (req.user && req.user.locale)
+    if (locale) reqOptions.headers['accept-language'] = locale
+  }
+
   if (reqOptions.data && reqOptions.method !== 'GET' && reqOptions.method !== 'HEAD') {
     reqOptions.headers['content-type'] = 'application/json'
     reqOptions.headers['content-length'] = Buffer.byteLength(JSON.stringify(reqOptions.data))
   }
-
   reqOptions.url = formatPath(reqOptions.url)
 
   if (service.path) reqOptions.url = `${encodeURI(service.path)}${reqOptions.url}`
@@ -376,20 +317,6 @@ const getReqOptions = (req, query, service) => {
   return reqOptions
 }
 
-// REVISIT: todo renaming for expanded entities
-// REVISIT: todo renaming for deep operations
-const postProcess = (query, result) => {
-  if (query.SELECT) {
-    handleAliasInResult(query.SELECT.columns, result)
-    return typeof query === 'object' && query.SELECT.one && Array.isArray(result) ? result[0] : result
-  }
-  if (query.DELETE) return result
-  let transition
-  if (query.INSERT) transition = query.INSERT._transitions[query.INSERT._transitions.length - 1]
-  if (query.UPDATE) transition = query.UPDATE._transitions[query.UPDATE._transitions.length - 1]
-  return revertData(result, transition)
-}
-
 const getAdditionalOptions = (req, destination, kind, resolvedTarget) => {
   const jwt = getJwt(req)
   const additionalOptions = { destination, kind, resolvedTarget }
@@ -397,14 +324,10 @@ const getAdditionalOptions = (req, destination, kind, resolvedTarget) => {
   return additionalOptions
 }
 
-const getDestination = (model, datasource, options) =>
-  createDestinationObject(findServiceName(model, datasource, options), options.credentials)
-
 module.exports = {
   getKind,
   run,
   getReqOptions,
-  postProcess,
   getDestination,
   getAdditionalOptions
 }

package/libx/_runtime/remote/utils/dataConversion.js

@@ -21,33 +21,40 @@ const DataTypeOData = {
 }
 
 const _convertData = (data, target, ieee754Compatible) => {
-  if (!Array.isArray(data)) {
-    return _convertRecord(target, ieee754Compatible)(data)
+  if (Array.isArray(data)) {
+    return data.map(record => _getConvertRecordFn(target, ieee754Compatible)(record))
   }
-  return data.map(_convertRecord(target, ieee754Compatible))
+
+  return _getConvertRecordFn(target, ieee754Compatible)(data)
 }
 
-const _convertRecord = (target, ieee754Compatible) => record => {
+const _getConvertRecordFn = (target, ieee754Compatible) => record => {
   for (const key in record) {
-    const value = record[key]
+    if (key === '__metadata') continue
+
     const element = target.elements[key]
+    if (!element) continue
+
+    const recordValue = record[key]
     const type = _elementType(element)
-    if (element) {
-      if (value && Array.isArray(value.results || value)) {
-        record[key] = _convertData(value.results || value, element._target, ieee754Compatible)
-      } else {
-        record[key] = _convertValue(value, type, ieee754Compatible)
-      }
+    const value = (recordValue && recordValue.results) || recordValue
+
+    if (value && (element.isAssociation || Array.isArray(value))) {
+      record[key] = _convertData(value, element._target, ieee754Compatible)
+    } else {
+      record[key] = _convertValue(value, type, ieee754Compatible)
     }
   }
+
   return record
 }
 
 // eslint-disable-next-line complexity
 const _convertValue = (value, type, ieee754Compatible) => {
-  if (value === null || value === undefined) {
+  if (value == null) {
     return value
   }
+
   if (['cds.Boolean'].includes(type)) {
     if (value === 'true') {
       value = true
@@ -62,21 +69,25 @@ const _convertValue = (value, type, ieee754Compatible) => {
     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\((.*)\)\//)
     const ticksAndOffset = match && match.pop()
+
     if (ticksAndOffset) {
       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
 }
 
@@ -88,16 +99,20 @@ const _calculateTicksOffsetSum = text => {
 
 const _elementType = element => {
   let type
+
   if (element) {
     type = element.type
+
     if (element['@odata.Type']) {
       const odataType = element['@odata.Type'].match(/\w+$/)
       type = (odataType && DataTypeOData[odataType[0]]) || type
     }
+
     if (!type && element.items && element.items.type) {
       type = element.items.type
     }
   }
+
   return type
 }
 

package/libx/_runtime/sqlite/Service.js

@@ -16,13 +16,11 @@ const convertAssocToOneManaged = require('./convertAssocToOneManaged')
 const execute = require('./execute')
 
 const _new = url => {
+  if (url && url !== ':memory:') url = cds.utils.path.resolve(cds.root, url)
+  if (!_sqlite) _sqlite = require('sqlite3')
   return new Promise((resolve, reject) => {
-    if (!_sqlite) {
-      _sqlite = require('sqlite3')
-    }
     const dbc = new _sqlite.Database(url, err => {
-      if (err) return reject(err)
-      resolve(dbc)
+      err ? reject(err) : resolve(dbc)
     })
   })
 }