@sap/cds 5.5.5 → 5.6.3

package/libx/{_runtime/odata/cqn2odata.js → odata/cqn2odata/index.js}

@@ -1,3 +1,5 @@
+const { formatVal } = require('../utils')
+
 const OPERATORS = {
   '=': 'eq',
   '!=': 'ne',
@@ -10,23 +12,13 @@ const OPERATORS = {
 
 const LAMBDA_VARIABLE = 'd'
 
-const getSafeNumber = str => {
-  const n = Number(str)
-  return Number.isSafeInteger(n) || String(n) === str ? n : str
-}
-
 const needArrayProps = Object.fromEntries(
-  ['where', 'search', 'xpr', 'columns', 'expand', 'orderBy', 'ref', 'args'].map(propName => [
+  ['where', 'search', 'xpr', 'columns', 'orderBy', 'ref', 'args'].map(propName => [
     propName,
-    cur =>
-      (Array.isArray(cur) && (cur.length !== 0 || propName === 'expand' || propName === 'ref')) ||
-      (propName === 'expand' && cur === '*')
+    cur => Array.isArray(cur) && (cur.length !== 0 || propName === 'expand' || propName === 'ref')
   ])
 )
 
-const V4UUIDREGEXP = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
-const isV4UUID = val => V4UUIDREGEXP.test(val)
-
 const validators = {
   SELECT: SELECT => SELECT && SELECT.from,
   INSERT: INSERT => {
@@ -50,63 +42,13 @@ const validators = {
   func: func => typeof func === 'string',
   one: count => typeof count === 'boolean',
   as: any => typeof any === 'string',
+  expand: any => any === '*' || Array.isArray(any),
   ...needArrayProps
 }
 
 // strip service & namespace prefixes
 const _entityUrl = path => path.match(/^(\w*\.)*(.*)$/)[2]
 
-const formatVal = (val, element, csnTarget, kind) => {
-  if (val === null || val === 'null') return 'null'
-  if (typeof val === 'boolean') return val
-  if (typeof val === 'number') return getSafeNumber(val)
-  if (!csnTarget && typeof val === 'string' && isV4UUID(val)) return kind === 'odata-v2' ? `guid'${val}'` : val
-
-  const csnElement = (csnTarget && csnTarget.elements && csnTarget.elements[element]) || { type: undefined }
-  return kind === 'odata-v2' ? _odataV2Val(val, csnElement.type) : _val(val, csnElement.type)
-}
-
-const _isTimestamp = val =>
-  /^\d+-\d\d-\d\d(T\d\d:\d\d(:\d\d(\.\d+)?)?(Z|([+-]{1}\d\d:\d\d))?)?$/.test(val) && !isNaN(Date.parse(val))
-
-const _odataV2Val = (val, type) => {
-  switch (type) {
-    case 'cds.Binary':
-    case 'cds.LargeBinary':
-      return `binary'${val}'`
-    case 'cds.Date':
-    case 'cds.DateTime':
-      return `datetime'${val}'`
-    case 'cds.Time':
-      // eslint-disable-next-line no-case-declarations
-      const [hh, mm, ss] = val.split(':')
-      return `time'PT${hh}H${mm}M${ss}S'`
-    case 'cds.Timestamp':
-      return `datetimeoffset'${val}'`
-    case 'cds.UUID':
-      return `guid'${val}'`
-    default:
-      return `'${val}'`
-  }
-}
-
-const _val = (val, type) => {
-  switch (type) {
-    case 'cds.Decimal':
-    case 'cds.Integer64':
-      return getSafeNumber(val)
-    case 'cds.Boolean':
-    case 'cds.DateTime':
-    case 'cds.Date':
-    case 'cds.Timestamp':
-    case 'cds.Time':
-    case 'cds.UUID':
-      return val
-    default:
-      return _isTimestamp(val) ? val : `'${val}'`
-  }
-}
-
 function getProp(obj, propName) {
   const validate = validators[propName]
   const isValid = validate && validate(obj[propName])
@@ -166,13 +108,25 @@ const _in = (column, /* in */ collection, target, kind, isLambda) => {
   }
 }
 
+const _odataV2Func = (func, args) => {
+  switch (func) {
+    case 'contains':
+      // this doesn't support the contains signature with two collections as args, introduced in odata v4.01
+      return `substringof(${_args([args[1], args[0]])})`
+    default:
+      return `${func}(${_args(args)})`
+  }
+}
+
 const _format = (cur, element, target, kind, isLambda) => {
   if (typeof cur !== 'object') return formatVal(cur, element, target, kind)
   if (hasValidProps(cur, 'ref')) return isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref.join('/')
   if (hasValidProps(cur, 'val')) return formatVal(cur.val, element, target, kind)
   if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda)})`
   // REVISIT: How to detect the types for all functions?
-  if (hasValidProps(cur, 'func', 'args')) return `${cur.func}(${_args(cur.args)})`
+  if (hasValidProps(cur, 'func', 'args')) {
+    return kind === 'odata-v2' ? _odataV2Func(cur.func, cur.args) : `${cur.func}(${_args(cur.args)})`
+  }
 }
 
 const _isLambda = (cur, next) => {
@@ -328,62 +282,48 @@ const _parseColumnsV2 = (columns, prefix = []) => {
   return { select, expand }
 }
 
-const _parseColumns = (columns, options) => {
-  const isExpand = options.expand
+const _parseColumns = columns => {
   const select = []
   const expand = []
 
-  if (columns === '*') {
-    return { select, expand }
-  }
-
-  const isSelectAll = select =>
-    select.length === 1 && (select[0] === '*' || (select[0].ref && select[0].ref[0] === '*'))
-
   for (const column of columns) {
     if (hasValidProps(column, 'ref')) {
-      const refName = column.ref.join('/')
-      let refNameWithOptions = refName
-
+      let refName = column.ref.join('/')
       if (hasValidProps(column, 'expand')) {
+        // REVISIT: incomplete, see test Foo?$expand=invoices($count=true;$expand=item($search="some"))
+        if (!columns.some(c => !c.expand)) select.push(refName)
         const curOptions = getOptions(column).join(';')
-        refNameWithOptions += curOptions ? `(${curOptions})` : ''
-        expand.push(refNameWithOptions)
-        if (!isSelectAll(select) && !isExpand) select.push(refName)
+        refName += curOptions ? `(${curOptions})` : ''
+        expand.push(refName)
         // REVISIT: expand to one & limit in options
-        // > const expanded = $expand(column.expand)
-        // > expand.push(expanded ? `${refNameWithOptions}(${expanded})` : ref)
+        // > const expanded = $expand(col.expand)
+        // > expand.push(expanded ? `${ref}(${expanded})` : ref)
         // see xtest('READ with expand'... in custom handler test
       } else {
-        select.push(refNameWithOptions)
+        select.push(refName)
       }
+    } else if (hasValidProps(column, 'expand') && column.expand === '*') {
+      expand.push('*')
     }
-
     if (column === '*') {
       select.push(column)
     }
   }
-
-  // omit $select query option if it only contains '*'
-  if (isSelectAll(select)) {
+  // omit '$select' option if contains only '*'
+  if (select.length === 1 && (select[0] === '*' || (select[0].ref && select[0].ref[0] === '*'))) {
     select.pop()
   }
-
-  const uniqueSelect = [...new Set(select)]
-  return { select: uniqueSelect, expand }
+  return { select, expand }
 }
 
-function $select(columns, kind, separator = '&', isExpand = false) {
-  const { select, expand } =
-    kind === 'odata-v2' ? _parseColumnsV2(columns) : _parseColumns(columns, { expand: isExpand })
-
+function $select(columns, kind, separator = '&') {
+  const { select, expand } = kind === 'odata-v2' ? _parseColumnsV2(columns) : _parseColumns(columns)
   const res = []
   if (expand.length) res.unshift('$expand=' + expand.join(','))
   if (select.length) res.unshift('$select=' + select.join(','))
   return res.join(separator)
 }
-
-const $expand = columns => $select(columns, 'odata', ';', true)
+const $expand = columns => $select(columns, 'odata', ';')
 
 function $count(count, kind) {
   if (count !== true) return ''
@@ -476,7 +416,9 @@ const _isOdataUrlWithKeys = (url, kind) => kind !== 'rest' && /^[\w\.]+\(.*\)/.t
 const parsers = {
   columns: (cqnPart, url, kind, target, isCount) => !isCount && $select(cqnPart, kind),
   expand: (cqnPart, url, kind, target, isCount) => !isCount && $expand(cqnPart),
+  // eslint-disable-next-line no-unused-vars
   where: (cqnPart, url, kind, target, isCount) => $where(cqnPart, target, kind),
+  // eslint-disable-next-line no-unused-vars
   search: (cqnPart, url, kind, target, isCount) => $search(cqnPart, kind),
   orderBy: (cqnPart, url, kind, target, isCount) => !isCount && $orderBy(cqnPart),
   count: (cqnPart, url, kind, target, isCount) => !isCount && $count(cqnPart, kind),
@@ -503,9 +445,7 @@ function getOptions(cqnPart, url, kind, target, isCount) {
 const _isCount = SELECT => {
   if (SELECT.columns) {
     const columns = getProp(SELECT, 'columns')
-    return columns.some(
-      c => c.func === 'count' && c.as === '$count' && c.args && c.args.length === 1 && c.args[0] === '*'
-    )
+    return columns.some(c => c.func === 'count' && c.as === '$count')
   }
   return false
 }
@@ -535,7 +475,6 @@ const _copyData = data => {
         ? data[property].val
         : data[property]
   }
-
   return copied
 }
 
@@ -581,4 +520,4 @@ function cqn2odata(cqn, kind, model) {
   throw new Error('Unknown CQN object cannot be translated to URL: ' + JSON.stringify(cqn))
 }
 
-module.exports = { cqn2odata, formatVal, getSafeNumber }
+module.exports = cqn2odata

package/libx/odata/index.js

@@ -0,0 +1,80 @@
+const cds = require('../_runtime/cds')
+const { SELECT } = cds.ql
+
+const odata2cqn = require('./odata2cqn')
+const cqn2odata = require('./cqn2odata')
+
+const afterburner = require('./odata2cqn/afterburner')
+const { getSafeNumber: safeNumber } = require('./utils')
+
+const strict = {
+  functions: {
+    contains: 1,
+    startswith: 1,
+    endswith: 1,
+    tolower: 1,
+    toupper: 1,
+    length: 1,
+    indexof: 1,
+    substring: 1,
+    trim: 1,
+    concat: 1,
+    year: 1,
+    month: 1,
+    day: 1,
+    hour: 1,
+    minute: 1,
+    second: 1,
+    time: 1,
+    now: 1
+  }
+}
+
+/*
+ * cds.odata API
+ */
+module.exports = {
+  parse: (url, options = {}) => {
+    // first arg may also be req
+    if (url.url) url = url.url
+    // REVISIT: for okra, remove when no longer needed
+    else if (url.getIncomingRequest) url = url.getIncomingRequest().url
+    url = decodeURIComponent(url)
+
+    options = options === 'strict' ? { strict } : options.strict ? { ...options, strict } : options
+    if (options.service) Object.assign(options, { minimal: true, afterburner: afterburner.for(options.service) })
+    options.safeNumber = safeNumber
+
+    let cqn
+    try {
+      cqn = odata2cqn(url, options)
+    } catch (e) {
+      // REVISIT: additional try in catch isn't nice -> find better way
+      // known gaps -> e.message is a stringified error -> use that
+      // unknown errors -> e is the error to keep
+      let err = e
+      try {
+        err = JSON.parse(e.message)
+      } catch {
+        /* nothing to do */
+      }
+      err.message = 'Parsing URL failed with error: ' + err.message
+      err.statusCode = err.statusCode || 400
+      throw err
+    }
+
+    if (typeof options.afterburner === 'function') cqn = options.afterburner(cqn)
+
+    const query = cqn.SELECT.one ? SELECT.one(cqn.SELECT.from) : SELECT.from(cqn.SELECT.from)
+    Object.assign(query.SELECT, cqn.SELECT)
+
+    // REVISIT: _target vs __target, i.e., pseudo csn vs actual csn
+    // DO NOT USE __target outside of libx/rest!!!
+    query.__target = cqn.__target
+
+    return query
+  },
+  urlify: (cqn, options = {}) => {
+    return cqn2odata(cqn, options.kind, options.model)
+  }
+}

package/libx/odata/odata2cqn/afterburner.js

@@ -0,0 +1,170 @@
+const cds = require('../../_runtime/cds')
+
+const { where2obj } = require('../../_runtime/common/utils/cqn')
+const { findCsnTargetFor } = require('../../_runtime/common/utils/csn')
+
+function _keysOf(entity) {
+  return entity && entity.keys
+    ? Object.keys(entity.keys).filter(
+        k => entity.elements[k].type !== 'cds.Association' && entity.elements[k]['@odata.foreignKey4'] !== 'up_'
+      )
+    : []
+}
+
+function _getDefinition(definition, name) {
+  return (
+    (definition.definitions && definition.definitions[name]) ||
+    (definition.elements && definition.elements[name]) ||
+    (definition.actions && definition.actions[name]) ||
+    definition[name]
+  )
+}
+
+function _resolveAliasInWhere(where, entity) {
+  if (!entity._alias2ref) return
+  for (let i = 0; i < where.length; i++) {
+    if (!where[i].ref || where[i].ref.length > 1 || entity.keys[where[i].ref[0]]) continue
+    where[i].ref = entity._alias2ref[where[i].ref[0]] || where[i].ref
+  }
+}
+
+// case: single key without name, e.g., Foo(1)
+function _addRefToWhereIfNecessary(where, entity) {
+  if (!where || where.length !== 1) return 0
+  const keys = _keysOf(entity)
+  if (keys.length !== 1) return 0
+  where.unshift(...[{ ref: [keys[0]] }, '='])
+  return 1
+}
+
+function _processSegments(cqn, model) {
+  const { ref } = cqn.SELECT.from
+
+  let current = model
+  let path
+  let keys = null
+  let keyCount = 0
+  let incompleteKeys
+  let one
+  for (let i = 0; i < ref.length; i++) {
+    const seg = ref[i].id || ref[i]
+    const params = ref[i].where && where2obj(ref[i].where)
+
+    if (incompleteKeys) {
+      // > key
+      keys = keys || _keysOf(current)
+      const key = keys[keyCount++]
+      one = true
+      const element = current.elements[key]
+      let base = ref[i - keyCount]
+      if (!base.id) base = { id: base, where: [] }
+      if (base.where.length) base.where.push('and')
+      base.where.push({ ref: [key] }, '=', { val: element.type === 'cds.Integer' ? Number(seg) : seg })
+      ref[i] = null
+      ref[i - keyCount] = base
+      incompleteKeys = keyCount < keys.length
+    } else {
+      // > entity or property (incl. nested) or navigation or action or function
+      keys = null
+      keyCount = 0
+      one = false
+
+      path = path ? path + `${path.match(/:/) ? '.' : ':'}${seg}` : seg
+      // REVISIT: replace use case: <namespace>.<entity>_history is at <namespace>.<entity>.history
+      current = _getDefinition(current, seg) || _getDefinition(current, seg.replace(/_/g, '.'))
+      // REVISIT: 404 or 400?
+      if (!current) cds.error(`Invalid resource path "${path}"`, { code: 404 })
+
+      if (current.kind === 'entity') {
+        // > entity
+        one = !!(ref[i].where || current._isSingleton)
+        incompleteKeys = ref[i].where ? false : i === ref.length - 1 || one ? false : true
+        if (ref[i].where) {
+          keyCount += _addRefToWhereIfNecessary(ref[i].where, current)
+          _resolveAliasInWhere(ref[i].where, current)
+        }
+      } else if ({ action: 1, function: 1 }[current.kind]) {
+        // > action or function
+        if (i !== ref.length - 1) {
+          const msg = `${i ? 'Unbound' : 'Bound'} ${current.kind} are only supported as the last path segment.`
+          throw Object.assign(new Error(msg), { statusCode: 501 })
+        }
+        ref[i] = { operation: current.name }
+        if (params) ref[i].args = params
+        if (current.returns && current.returns.type) one = true
+      } else if (current.isAssociation) {
+        // > navigation
+        one = !!(current.is2one || ref[i].where)
+        incompleteKeys = one || i === ref.length - 1 ? false : true
+        current = model.definitions[current.target]
+        if (ref[i].where) {
+          keyCount += _addRefToWhereIfNecessary(ref[i].where, current)
+          _resolveAliasInWhere(ref[i].where, current)
+        }
+      } else if (current._isStructured) {
+        // > nested property
+        one = true
+        current = current.elements
+      } else {
+        // > property
+        one = true
+      }
+    }
+  }
+
+  if (incompleteKeys) {
+    // > last segment not fully qualified
+    throw Object.assign(
+      new Error(
+        `Entity "${current.name}" has ${_keysOf(current).length} keys. Only ${keyCount} ${
+          keyCount === 1 ? 'was' : 'were'
+        } provided.`
+      ),
+      { status: 400 }
+    )
+  }
+
+  // remove all nulled refs
+  cqn.SELECT.from.ref = ref.filter(r => r)
+
+  // one?
+  if (one) cqn.SELECT.one = true
+
+  // REVISIT: better
+  // set target (csn definition) for later retrieval
+  cqn.__target = current
+}
+
+function _4service(service) {
+  const { namespace, model } = service
+
+  return cqn => {
+    const { ref } = cqn.SELECT.from
+
+    // REVISIT: shouldn't be necessary
+    /*
+     * make first path segment fully qualified
+     */
+    const root = findCsnTargetFor(ref[0].id || ref[0], model, namespace)
+    // REVISIT: 404 or 400?
+    if (!root) cds.error(`Invalid resource path "${namespace}.${ref[0].id || ref[0]}"`, { code: 404 })
+    if (ref[0].id) ref[0].id = root.name
+    else ref[0] = root.name
+
+    /*
+     * key vs. path segments (/Books/1/author/books/2/...) and more
+     */
+    _processSegments(cqn, model)
+
+    return cqn
+  }
+}
+
+const cache = new WeakMap()
+
+module.exports = {
+  for: service => {
+    if (!cache.has(service)) cache.set(service, _4service(service))
+    return cache.get(service)
+  }
+}