@sap/cds 6.1.2 → 6.2.1

package/libx/_runtime/sqlite/convertAssocToOneManaged.js

@@ -37,7 +37,7 @@ const _convert = (refEntries, req) => {
 }
 
 // REVISIT once sql can handle structured keys properly, this handler should not be required anymore
-const _handler = function (req) {
+const sqliteConvertAssocToOneManaged = function (req) {
   // do simple checks upfront and exit early
   if (!(req.query && req.query.SELECT) || typeof req.query === 'string') return
   if (!req.query.SELECT.orderBy && !req.query.SELECT.groupBy && !req.query.SELECT.where && !req.query.SELECT.having) {
@@ -49,6 +49,6 @@ const _handler = function (req) {
   _convert(_getConvertibleEntries(req), req)
 }
 
-_handler._initial = true
+sqliteConvertAssocToOneManaged._initial = true
 
-module.exports = _handler
+module.exports = sqliteConvertAssocToOneManaged

package/libx/_runtime/sqlite/localized.js

@@ -7,6 +7,8 @@ if (cds.env.i18n && Array.isArray(cds.env.i18n.for_sqlite) && !cds.env.i18n.for_
   LOG._warn && LOG.warn('No language configuration found in cds.env.i18n.for_sqlite')
 }
 
+const _translations = cds.env.i18n.for_sqlite.reduce((all, l) => ((all[l] = true), all), {})
+
 // REVISIT: this is actually configurable
 // there is no localized.en.<name>
 const getLocalize = (locale, model) => name => {
@@ -15,15 +17,13 @@ const getLocalize = (locale, model) => name => {
   // if we get here via onReadDraft, target is already localized
   // because of subrequest using SELECT.from as new target
   const target = model.definitions[ensureUnlocalized(name)]
-  const localizedView =
-    target &&
-    target['@cds.localized'] !== false &&
-    model.definitions[`localized.${locale !== 'en' ? locale + '.' : ''}${name}`]
+  if (target?.['@cds.localized'] === false) return name
 
-  return localizedView ? localizedView.name : name
+  const view = model.definitions[`localized${locale in _translations ? '.' + locale : ''}.${name}`]
+  return view?.name || name
 }
 
-const _handler = function (req) {
+const sqliteLocalized = function (req) {
   const { query } = req
 
   // do simple checks upfront and exit early
@@ -44,6 +44,6 @@ const _handler = function (req) {
   redirect(query, getLocalize(req.locale, this.model))
 }
 
-_handler._initial = true
+sqliteLocalized._initial = true
 
-module.exports = _handler
+module.exports = sqliteLocalized

package/libx/odata/afterburner.js

@@ -163,20 +163,27 @@ function _convertVal(element, value) {
   if (value === null) return value
   switch (element._type) {
     case 'cds.Integer':
+    case 'cds.UInt8':
+    case 'cds.Int16':
+    case 'cds.Int32':
       // eslint-disable-next-line no-case-declarations
       const n = Number(value)
       if (Number.isSafeInteger(n)) return n
       throw new Error('Not a valid integer') // TODO
+
     case 'cds.String':
     case 'cds.LargeString':
     case 'cds.Decimal':
     case 'cds.DecimalFloat':
     case 'cds.Double':
+    case 'cds.Int64':
     case 'cds.Integer64':
       if (typeof value === 'string') return value
       return String(value)
+
     case 'cds.Boolean':
       return typeof value === 'string' ? value === 'true' : value
+
     default:
       return value
   }
@@ -189,12 +196,13 @@ function _processSegments(from, model, namespace) {
   let path
   let keys = null
   let keyCount = 0
-  let incompleteKeys
+  let incompleteKeys = false
   let one
   let target
   for (let i = 0; i < ref.length; i++) {
     const seg = ref[i].id || ref[i]
-    let params = ref[i].where && where2obj(ref[i].where)
+    const whereRef = ref[i].where
+    let params = whereRef && where2obj(whereRef)
 
     if (incompleteKeys) {
       // > key
@@ -234,7 +242,7 @@ function _processSegments(from, model, namespace) {
       if (current.params && current.kind === 'entity') {
         // > View with params
         target = current
-        if (ref[i].where) {
+        if (whereRef) {
           keyCount += addRefToWhereIfNecessary(ref[i].where, current)
           _resolveAliasesInXpr(ref[i].where, current)
           _resolveAliasInParams(params, current)
@@ -265,10 +273,28 @@ function _processSegments(from, model, namespace) {
         // > entity
         target = current
         one = !!(ref[i].where || current._isSingleton)
+
+        let action
+        if (current.actions) {
+          const nextRef = typeof ref[i + 1] === 'string' && ref[i + 1]
+          const shortName = nextRef && nextRef.replace(namespace + '.', '')
+          action = shortName && current.actions[shortName]
+        }
+
         incompleteKeys = ref[i].where ? false : i === ref.length - 1 || one ? false : true
-        if (ref[i].where) {
-          keyCount += addRefToWhereIfNecessary(ref[i].where, current)
-          _resolveAliasesInXpr(ref[i].where, current)
+
+        if (incompleteKeys && action) {
+          if (action['@cds.odata.bindingparameter.collection']) {
+            incompleteKeys = false
+          } else {
+            const msg = `Bound operations are not supported on entity collections.`
+            throw Object.assign(new Error(msg), { statusCode: 501 })
+          }
+        }
+
+        if (whereRef) {
+          keyCount += addRefToWhereIfNecessary(whereRef, current)
+          _resolveAliasesInXpr(whereRef, current)
           _resolveAliasInParams(params, current)
           // in case of Foo(1), params will be {} (before addRefToWhereIfNecessary was called)
           if (!Object.keys(params).length) params = where2obj(ref[i].where)
@@ -277,6 +303,11 @@ function _processSegments(from, model, namespace) {
         }
       } else if ({ action: 1, function: 1 }[current.kind]) {
         // > action or function
+        if (current.kind === 'action' && ref && ref[ref.length - 1]?.where?.length === 0) {
+          const msg = `Round brackets (parentheses) are not allowed for action calls.`
+          throw Object.assign(new Error(msg), { statusCode: 400 })
+        }
+
         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 })
@@ -401,7 +432,8 @@ function _4service(service) {
     const { ref } = from
 
     // REVISIT: shouldn't be necessary
-    //Second findCsnTargetFor is required for concat query, where the root is already identified with the first query and subsequent queries already have correct root
+    // Second findCsnTargetFor is required for concat query, where the root is already identified with the first query
+    // and subsequent queries already have correct root
     /*
      * make first path segment fully qualified
      */

package/libx/odata/cqn2odata.js

@@ -121,8 +121,11 @@ const _format = (cur, elementName, target, kind, isLambda) => {
   if (hasValidProps(cur, 'val')) return encodeURIComponent(formatVal(cur.val, elementName, 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 kind === 'odata-v2' ? _odataV2Func(cur.func, cur.args) : `${cur.func}(${_args(cur.args)})`
+  if (hasValidProps(cur, 'func')) {
+    if (cur.args?.length) {
+      return kind === 'odata-v2' ? _odataV2Func(cur.func, cur.args) : `${cur.func}(${_args(cur.args)})`
+    }
+    return `${cur.func}()`
   }
 }
 
@@ -474,7 +477,7 @@ const parsers = {
   count: (cqnPart, url, kind, target, isCount) => !isCount && $count(cqnPart, kind),
   limit: (cqnPart, url, kind, target, isCount) => !isCount && $limit(cqnPart),
   one: (cqnPart, url, kind, target, isCount) => !isCount && $one(cqnPart, url, kind),
-  ref: (cqnPart, url, kind, target, isCount) => cqnPart[0].where && $where(cqnPart[0].where, target, kind)
+  ref: (cqnPart, url, kind, target, _isCount) => cqnPart[0].where && $where(cqnPart[0].where, target, kind)
 }
 
 function getOptions(cqnPart, url, kind, target, isCount) {

package/libx/odata/grammar.pegjs

@@ -238,6 +238,35 @@
       }
       return elements
     }
+
+    const _replaceAliasedInWhere = (where, alias, value, isFromWhere = false) =>  {
+      where?.forEach(element => {
+        if (element.val === alias) {
+          // TODO check if we want to store replaced aliases/values for req.data in actions/functions in CQN 
+          element.val = value.val
+        } else if (element.list === alias) {
+          element.list = value.list
+        } else if (element.func) {
+          element.args.forEach((arg, i) => {
+            if (arg.val === alias) {
+              arg.val = value.val
+            } else if (arg.func) {
+              _replaceAliasedInWhere(arg.args, alias, value, isFromWhere)
+            }
+          })
+        } else if (element.SELECT) {
+          _replaceAliased(element.SELECT, alias, value, isFromWhere)
+        }
+      });
+    }
+    const _replaceAliased = (select, alias, value, isFromWhere = false) =>  {
+      const {where, from} = select
+      _replaceAliasedInWhere(where, alias, value);
+
+      from?.ref?.forEach(element => {
+        _replaceAliasedInWhere(element.where, alias, value, true);
+      })
+    }
   }
 
 // ---------- Entity Paths ---------------
@@ -334,11 +363,13 @@
 
   QueryOption = option:ExpandOption { if(option && option.apply) SELECT.apply = option.apply} /
     "$skiptoken="   o skiptoken /
+    temporal /
     format /
     custom /
     aliasedParamEqualsVal
   // @OData spec for $expand:
-  // "Allowed system query options are $filter, $select, $orderby, $skip, $top, $count, $search, $expand and $apply (http://docs.oasis-open.org/odata/odata-data-aggregation-ext/v4.0/cs02/odata-data-aggregation-ext-v4.0-cs02.html#_The_expand_Transformation)."
+  // "Allowed system query options are $filter, $select, $orderby, $skip, $top, $count, $search, $expand and 
+  // $apply (https://go.sap.corp/0jzs)."
   ExpandOption =
     "$select="      o select ( COMMA select )* /
     "$expand="      o expand ( COMMA expand )* expandCount? /
@@ -350,6 +381,7 @@
     "$count="       o count /
     "$apply="       o trafos:transformations { return trafos }
 
+  temporal = ("$at" / "$from" / "$toInclusive" / "$to") "=" date
 
   select
     = col:('*' / ref) {
@@ -360,7 +392,7 @@
 
   expandCount 
     = "/$count" {
-      const err = new Error("EXPAND_COUNT_UNSUPPORTED");
+      const err = new Error('"/$count" is not supported for expand operation');
       err.statusCode=501;
       throw err;
     }
@@ -370,7 +402,7 @@
       expandOptions:(option:ExpandOption o ";"? { return option })*
       {
       	if (expandOptions.find(option => option && option.apply !== undefined)) {
-        	const err = new Error("EXPAND_APPLY_UNSUPPORTED");
+        	const err = new Error('"$apply" is not supported for expand operation');
       		err.statusCode=501;
       		throw err;
         }
@@ -468,12 +500,16 @@
         for (let i=0, k=0; i<any.length; ++i) {
           let each = any[i]
           if (each.ref && each.ref.length === 0 && any[i+1] === '=') {
-            xpr[k++] = { func:'contains', args:[{ref:id}, any[i+=2]] }
+            xpr[k++] = { func:'contains', args:[{ref:[id]}, any[i+=2]] }
           } else {
             xpr[k++] = each
           }
         }
         if (xpr.length < any.length) {
+          if (!nav.length) {
+            // no navigation
+            return xpr
+          }
           id = nav.pop()
           return ['exists', { ref: [...nav, { id, where: xpr }] }]
         } else {
@@ -493,7 +529,7 @@
       / comp:comparison { p.push(...comp) }
       / func:function { p.push(func) }
       / lambda:lambda { p.push(...lambda)}
-      / list:listFilter {p.push(...list)}
+      / list:listFilter { p.push(...list) }
     )
     ( ao:(AND/OR) more:inner_lambda { p.push(ao, ...more) } )*
     { return p }
@@ -512,7 +548,7 @@
   orderby
     = ref:(
         lambda {
-          const err = new Error("ORDERBY_LAMBDA_UNSUPPORTED");
+          const err = new Error('"$orderby" does not support lambda');
           err.statusCode=501;
           throw err;
         } /
@@ -560,14 +596,18 @@
       return {apply: mainTransformation}
     }
 
+  aliasedParamVal = val / jsonObject / jsonArray / "[" list:innerList "]" { return { list } }
+
   custom
     = [a-zA-Z0-9-_.~]+ "=" [^&]*
   aliasedParam "an aliased parameter (@param)" = "@" i:identifier { return "@" + i }
-  aliasedParamEqualsVal "@alias=value" = a:aliasedParam "=" v:([^&]*) {return a + "=" + v} 
+  aliasedParamEqualsVal = alias:aliasedParam "=" !aliasedParam value:aliasedParamVal {
+    _replaceAliased(SELECT, alias, value);
+  }
 
   format = "$format=" f:$([^&]*) {
     if (f.toLowerCase() !== "json") {
-      const err = new Error("ONLY_QUERY_PARAM_FORMAT_JSON_ALLOWED")
+      const err = new Error('Only query parameter "json" is allowed in "$format".')
       err.statusCode = 501
       throw err;
     }
@@ -581,10 +621,13 @@
       return [ a, op, b ]
     }
 
+  listFilterParam = aliased:aliasedParam { return { list: aliased } } / listRoundBrackets
+
   listFilter
-    = a:operand _ "in" _ b:listRoundBrackets {
+    = a:operand _ "in" _ b:listFilterParam {
       return [ a, "in", b ]
     }
+
   mathCalc
     = operand (_ ("add" / "sub" / "mul" / "div" / "mod") _ operand)*
   
@@ -621,36 +664,39 @@
 
   null "null" =  "null" {return {val: null }}
   
+  // REVISIT why not JSON.parse() and return JS object?
   jsonObject "a json object"
     = val:$("{" (jsonObject / [^}])* "}") {return {val}}
   
+  // REVISIT why not JSON.parse() and return JS array?
   jsonArray "a json array"
     = val:$("[" o "]" / "[" o "{" (jsonArray / [^\]])* "]") {return {val}}
 
+  // REVISIT: only used for contains(identifier, ["searchterm"]) <- use innerList instead?
   list "a list"
     = "[" any:$([^\]])* "]" // > needs improvment
     { return { list: any.replace(/"/g,'').split(',').map(ele => ({ val: ele })) } }
 
+  innerList = (val1:val val2:("," v:val { return v })* { return [val1, ...val2] })
+
   listRoundBrackets "a list"
-    = OPEN list:(val1:val val2:("," v:val { return v })* { return [val1, ...val2] }) CLOSE // > needs improvment
-    { 
-      return { list }
-    }
+    = OPEN list:innerList CLOSE // > needs improvment
+    { return {list} }
 
   
   functionName "a function name"
   = $[a-zA-Z]+
 
   function 
-    = func:functionName OPEN fnArgs:functionArgs CLOSE {
+    = func:functionName OPEN args:functionArgs CLOSE {
       if (strict && !(func.toLowerCase() in strict.functions)) {
         throw Object.assign(new Error(`"${func}" is an unknown function in OData URL spec (strict mode)`), { statusCode: 400 })
       }
-      return { func: func.toLowerCase(), args:[fnArgs.a,...fnArgs.more] }
+      return { func: func.toLowerCase(), args }
     }
 
   functionArgs
-    = a:operand more:( COMMA o:operand {return o} )* {return { a, more }}
+    = args:(a:operand more:( COMMA o:operand { return o } )* { return [ a, ...more ] })* { return args.length ? args[0] : args }
 
   boolish
     = func:("contains"i/"endswith"i/"startswith"i) OPEN a:operand COMMA b:operand CLOSE
@@ -758,13 +804,15 @@
     return {concat: [trafo1, ...trafo2]}
   }
 
-  computeTrafo = OPEN o computeExpr (o COMMA o computeExpr)* o CLOSE //REVISIT: support compute - current implementation is deviating from odata
+  // REVISIT: support compute - current implementation is deviating from odata
+  computeTrafo = OPEN o computeExpr (o COMMA o computeExpr)* o CLOSE
 
   computeExpr = where_clause asAlias
 
   commonFuncTrafo = OPEN o first:operand o COMMA o second:operand o CLOSE { return [first, second] }
 
-  identityTrafo = "identity" {return {identity: true }} //REVISIT: support identity
+  // REVISIT: support identity
+  identityTrafo = "identity" {return {identity: true }}
 
   topTrafo
     = OPEN o val:top o CLOSE {

package/libx/odata/index.js

@@ -1,4 +1,4 @@
-const cds = require('../_runtime/cds')
+const cds = require('../_runtime/cds'), { decodeURIComponent } = cds.utils
 const { SELECT } = cds.ql
 
 const odata2cqn = require('./parser').parse
@@ -64,7 +64,7 @@ module.exports = {
     // REVISIT: for okra, remove when no longer needed
     else if (url.getIncomingRequest) url = url.getIncomingRequest().url
 
-    url = decodeURIComponent(url)
+    url = decodeURIComponent(url) // REVISIT: do we need that?
 
     options = options === 'strict' ? { strict } : options.strict ? { ...options, strict } : options
     if (options.service) Object.assign(options, { minimal: true, afterburner: afterburner.for(options.service) })
@@ -101,6 +101,7 @@ module.exports = {
 
     return cqn
   },
+
   urlify: (cqn, options = {}) => {
     return cqn2odata(cqn, options)
   }