@sap/cds 9.0.3 → 9.1.0

package/libx/odata/parse/grammar.peggy

@@ -177,7 +177,9 @@
 
     const _handleApply = (cqn, apply) => {
       let newCqn = _convertApply({ from: cqn.from }, apply)
-      
+      //Delete apply as it was successfully converted & to not spill into final query
+      delete cqn.apply
+      //Normal query options have to be applied after convert, as _convertApply calls itself recursively and else normal options might be redundant in nested SELECTs
       if (Array.isArray(newCqn)) {
         for (let i = 0; i < newCqn.length; i++) {
           newCqn[i] = _addNormalQueryOptions(newCqn[i], cqn)
@@ -185,99 +187,102 @@
       } else {
         newCqn = _addNormalQueryOptions(newCqn, cqn)
       }
-
+      if (newCqn.SELECT?.recurse && cqn.where) {
+        const where = cqn.where 
+        delete cqn.where
+        newCqn = { SELECT: { from: newCqn, where } }
+      }
       return newCqn
     }
 
-    const _addNormalQueryOptions = (cqn, topCqn) => {
-      if (!topCqn) return cqn
-      if (topCqn.apply) delete topCqn.apply
+    function isQueryWithAggregation(cqn) {
+      return cqn.SELECT.groupBy ||
+          cqn.SELECT.columns?.some(col => col && typeof col === 'object' && 'func' in col)
+    }
 
-      let newCqn = {}
+    // topCqn is not allowed to be mutated as that would spill in case of concat transformations
+    const _addNormalQueryOptions = (cqn, topCqn) => {
+      const QUERY_WITH_AGGREGATION = isQueryWithAggregation(cqn);
       if (
         (topCqn.columns && topCqn.columns[0].as === '$count') ||
-        (cqn.SELECT.where && topCqn.where) ||
+        //In QUERY_WITH_AGGREGATION topCqn.where is a having and thus no further nesting needed
+        (!QUERY_WITH_AGGREGATION && topCqn.where && (cqn.SELECT.where || cqn.SELECT.limit)) ||
         (cqn.SELECT.limit && topCqn.limit) ||
         (cqn.SELECT.orderBy && topCqn.orderBy) ||
         (cqn.SELECT.search && topCqn.search)
       ) {
-        newCqn.from = cqn
-      } else newCqn = cqn.SELECT
-
-
-      // Collect & Select Aggregated Columns
-      const aggregatedColumns = newCqn.columns && newCqn.columns.length
-        ? newCqn.columns.filter(col => col && typeof col === 'object' && 'func' in col)
-        : []
-      newCqn.columns = aggregatedColumns.length ? aggregatedColumns : []
-
-      if (newCqn.groupBy && newCqn.groupBy.length) {
-        // Expand & Select Columns from GroupBy
-
-        const groupByColumns = newCqn.groupBy.reduce((expandedGroupByColumns, column) => {
-            if (column.ref && column.ref.length > 1) {
-              const columnToExpand = { ref: [...column.ref] }
-              if (column.expand && column.expand.length) columnToExpand.expand = [...column.expand]
-              if (column.as) columnToExpand.as = column.as
-              _expand(expandedGroupByColumns, columnToExpand, true)
-            } else expandedGroupByColumns.push({ ...column })
-            return expandedGroupByColumns
-          }, [])
-
-          newCqn.columns ??= []
-          newCqn.columns.push(...groupByColumns)
-      }
-
-      for (const queryOption in topCqn) {
-        if (queryOption === 'columns') {
-          const mergedColumns = []
-
-          // Add aggregation columns 
-          if (newCqn.columns.length) mergedColumns.push(...newCqn.columns)
-
-          // Use columns from parsed CQN if there's no grouping
-          if (!newCqn.groupBy || !newCqn.groupBy.length) {   
-            for (const column of topCqn.columns) 
-              if (!mergedColumns.some(_compareRefs(column))) mergedColumns.push(column)
+        //Have topCqn as new cqn but assign existing cqn as SELECT.from.SELECT 
+        const newCqn = Object.assign({}, topCqn)
+        newCqn.from = cqn;
+        cqn = {SELECT: newCqn}
+      } else {
+        let from = cqn.SELECT.from;
+        let columns = cqn.SELECT.columns;
+        //Needed in case topCqn.where is a having and not a where
+        let originalWhere = cqn.SELECT.where;
+        // cqn.SELECT must be the base as else concat queries would be overridden
+        cqn.SELECT = Object.assign(cqn.SELECT, topCqn)
+        //Reapplied to ensure SELECT.from.SELECT is not lost
+        cqn.SELECT.from = from;
+        //Reapplied as topCqn.columns have special handling further down below to be merged into existing columns
+        cqn.SELECT.columns = columns;
+
+        // When a group by already exists or a column is aggregated and a where follows it is a having
+        // In the scenario where a topCqn.where exists and the query is not aggregating, topCqn.where is used as the cqn.SELECT.where. 
+        // Those cannot conflict as the top if statement ensures that in this case a SELECT.from.SELECT is created
+        if (QUERY_WITH_AGGREGATION && topCqn.where) {
+          const newHaving = topCqn.where
+              .map(_remapFunc(cqn.SELECT.columns))
+              //In a query with only aggregation groupBy would be undefined causing a crash
+              .map(_replaceNullRef(cqn.SELECT.groupBy ?? []));
+          if (!cqn.SELECT.having) {
+            cqn.SELECT.having = newHaving
           } else {
-            _mergeColumnForests(mergedColumns, topCqn.columns)
+            //The existing cqn.SELECT.having was already mapped in _convertApply
+            cqn.SELECT.having = [
+              {xpr: cqn.SELECT.having}, 
+              'and',
+              {xpr: newHaving}
+            ];
           }
+          //Correct back to original where
+          cqn.SELECT.where = originalWhere;
+        }
+      }
 
-          newCqn.columns = mergedColumns
+      if (topCqn.columns) {
+        const mergedColumns = [];
+        if (!cqn.SELECT.columns) {
+          cqn.SELECT.columns = [];
+        }
+        // Add aggregation columns 
+        if (cqn.SELECT.columns.length) {
+          mergedColumns.push(...cqn.SELECT.columns)
+        }
 
-        } else if (queryOption !== 'from') {
-          newCqn[queryOption] = topCqn[queryOption]
+        // Use columns from parsed CQN if there's no grouping
+        if (!cqn.SELECT.groupBy || !cqn.SELECT.groupBy.length) {   
+          for (const column of topCqn.columns) {
+            if (!mergedColumns.some(_compareRefs(column))) {
+              mergedColumns.push(column)
+            }
+          }
+        } else {
+          _mergeColumnForests(mergedColumns, topCqn.columns)
         }
+        // topCqn is later applied to cqn.SELECT and thus the merged columns have to be assigned to them
+        cqn.SELECT.columns = mergedColumns
       }
       
-      if (newCqn.groupBy && newCqn.where) {
-        // Replace Where by Having, to be evaluated after GroupBy
-
-        newCqn.having = newCqn.where
-          .map(_remapFunc(newCqn.columns))
-          .map(_replaceNullRef(newCqn.groupBy))
-        delete newCqn.where
-      }
-
-      if (!newCqn.columns.length) delete newCqn.columns
-      return { SELECT: newCqn }
+      if (!cqn.SELECT.columns?.length) delete cqn.SELECT.columns
+      return cqn
     }
 
     const _convertApply = (cqn, apply) => {
-      if (!apply) return
-
-      if (cqn.apply) delete cqn.apply
+      delete cqn.apply
       if (apply.identity && cqn.from.SELECT) cqn = cqn.from.SELECT
-      if (
-        apply.apply ||
-        (apply.where && cqn.where) ||
-        (apply.search && cqn.search) ||
-        (apply.limit && cqn.limit) ||
-        (apply.orderBy && cqn.orderBy)
-      ) {
-        cqn.from = { SELECT: { ...cqn } }
-      }
-
+      if (apply.apply) cqn.from = { SELECT: { ...cqn } }
+      
       const _toplevels = cqn => {
         cqn.recurse = { ref: ['parent'] }
 
@@ -370,36 +375,60 @@
       if (apply.search) cqn.search = apply.search
       if (apply.limit) cqn.limit = apply.limit
       if (apply.orderBy) cqn.orderBy = apply.orderBy
+
       if (apply.groupBy)
         cqn.groupBy = apply.groupBy.reduce((groupBy, column) => {
           if (!groupBy.some(_compareRefs(column))) groupBy.push(column)
           return groupBy
         }, [])
 
-      if (apply.aggregate && apply.aggregate.length) cqn.columns = [...(cqn.columns || []), ...apply.aggregate]
-      if (cqn.groupBy && cqn.groupBy.length) cqn.columns = [...(cqn.columns || []), ...cqn.groupBy]
-
-      if (apply.apply && cqn.from) _convertApply(cqn.from.SELECT, apply.apply)
+      if (apply.aggregate && apply.aggregate.length) {
+        cqn.columns = (cqn.columns || []).concat(apply.aggregate);
+      }
+      if (cqn.groupBy && cqn.groupBy.length) {
+        const groupByColumns = cqn.groupBy.reduce((expandedGroupByColumns, column) => {
+            if (column.ref && column.ref.length > 1) {
+              const columnToExpand = { ref: [...column.ref] }
+              if (column.expand && column.expand.length) columnToExpand.expand = [...column.expand]
+              if (column.as) columnToExpand.as = column.as
+              _expand(expandedGroupByColumns, columnToExpand, true)
+            } else expandedGroupByColumns.push({ ...column })
+            return expandedGroupByColumns
+          }, [])
+        cqn.columns = (cqn.columns || []).concat(groupByColumns);
+      }
+      if (apply.having) {
+        cqn.having = apply.having
+          .map(_remapFunc(cqn.columns))
+          .map(_replaceNullRef(cqn.groupBy ?? []))
+      }
       
-      if (apply.concat && Array.isArray(apply.concat)) {
-        const additionalQueries = []
-
+      if (apply.apply) {
+        _convertApply(cqn.from.SELECT, apply.apply)
+      }
+      
+      if (Array.isArray(apply.concat)) {
+        const concatenatedQueries = []
+        // Refrain from nesting if no property other than 'from' was transferred from apply to cqn
+        // With concat the current level SELECT is the base for multiple queries, and is used as the FROM clause in those, 
+        // thus it has to be wrapped in a SELECT for a proper CQN structure, like SELECT.from.SELECT.<cqn-props>
+        // However if concat is the first transformation the SELECT just has the from and thus SELECT.from.SELECT nesting can be avoided
+        const newFrom = Object.keys(cqn).length === 1
+          ? cqn.from
+          : { SELECT: cqn } 
         for (let select of apply.concat) {
-          select.from = Object.keys(cqn).length === 1
-            ? cqn.from
-            : { SELECT: cqn } 
-
-          const nextCqn = _convertApply(select, select.apply)
-          
-
-          if (Array.isArray(nextCqn)) additionalQueries.push(...nextCqn)
-          else additionalQueries.push(nextCqn)
+          select.from = newFrom
+          if (select.apply) {
+            const nextCqn = _convertApply(select, select.apply)
+            if (Array.isArray(nextCqn)) {
+              concatenatedQueries.push(...nextCqn)
+            } else {
+              concatenatedQueries.push(nextCqn)
+            }
+          }
         }
-
-        cqn = additionalQueries
+        return concatenatedQueries
       }
-      
-      if (Array.isArray(cqn)) return cqn
       return { SELECT: cqn }
     }
 
@@ -527,7 +556,7 @@
     = "$count" {count = true}
     / rv:$("$ref"/"$value") {return !TECHNICAL_OPTS.includes(rv) && {from: {ref: [rv]}}}
     / head:(
-      (identifier filter:(OPEN CLOSE/OPEN args CLOSE)? !segment) / val:segment{return [val]}
+      (identifier filter:(OPEN CLOSE/OPEN guardedargs CLOSE)? !segment) / val:segment{return [val]}
     )? tail:((s:"/" {return s;}) path?)? {
       tail = tail && tail[1]
       if (!head && !tail) {
@@ -575,6 +604,14 @@
       return args
     }
 
+  guardedargs
+    = ref:ref o"="o val:guardedval more:( COMMA guardedargs )? {
+      const args = [ ref, '=', val ]
+      if (more) args.push ('and', ...more[1])
+      return args
+    }
+    / val:guardedval {return [val]}
+
   // `path` cannot be used in hierarchy functions, hence use a simpler definition
   simplePath
     = i:identifier filter:(OPEN CLOSE/OPEN a:args CLOSE{ return a })? tail:("/" s:simplePath{ return s })*{
@@ -798,38 +835,6 @@
   count
     = val:bool { if(val) SELECT.count = true }
 
-  transformations
-    = mainTransformation:trafo additionalTransformation:("/" t2:trafo {
-      return t2
-    })* {
-    	if(mainTransformation === undefined) return
-      additionalTransformation = (Array.isArray(additionalTransformation)) ? additionalTransformation : [additionalTransformation] 
-      // Loop through additionalTransformation
-      // Loop through each element, add it to current level, if element is already part of result, increase level
-      for(let trafos of additionalTransformation) {
-        for(const trafo in trafos) {
-          if (trafo === 'limit' && trafos.limit && mainTransformation.limit && mainTransformation.limit.offset && trafos.limit.rows)
-            mainTransformation.limit.rows = trafos.limit.rows
-          else if(
-          	mainTransformation[trafo] || 
-            (trafo === 'groupBy' && (mainTransformation.where || mainTransformation.search)) || 
-            (trafo === 'aggregate' && 'groupBy' in mainTransformation && !('groupBy' in trafos))
-          ) {
-            let _apply = mainTransformation
-            mainTransformation = { apply: _apply } 
-            if (trafo === 'limit' && trafos[trafo].offset && _apply.limit && _apply.limit.offset && _apply.limit.offset.val)
-              trafos[trafo].offset += _apply.limit.offset.val
-            
-            _apply = mainTransformation
-            _apply[trafo] = trafos[trafo]
-          } else {
-            mainTransformation[trafo] = trafos[trafo]
-          }
-        }
-      }
-      return {apply: mainTransformation}
-    }
-
   deltaToken = "$deltatoken=" o token:([^&]*) { return token }
 
     valList "value with double-quoted string"
@@ -840,8 +845,8 @@
 
   aliasedParamVal = val / jsonObject / jsonArray / "[" list:innerListParam "]" { return { list } }
 
-  custom = k:$([[a-zA-Z0-9-_.~!\[\]]+) "="? v:$([^&]*)? {
-    _custom(k, v)
+  custom = k:$([a-zA-Z0-9_.~!\[\]\-]+) "="? v:$([^&]*)? {
+    return _custom(k, v)
   }
 
   aliasedParam "an aliased parameter (@param)" = "@" i:identifier { return "@" + i }
@@ -904,7 +909,7 @@
       }
       return { ref:[ head, ...tail ] }
     }
-
+  
   val
     = val:bool {return {val}}
     / val:date {return {val}}
@@ -916,6 +921,10 @@
     / val:aliasedParam {return {val}}
     / null
 
+    guardedval
+    = val:val {return val}
+    / val:simpleword {throw Object.assign(new Error(`Invalid value: ${val}`), { statusCode: 400 })};
+  
   null "null" =  "null" {return {val: null }}
   
   // REVISIT why not JSON.parse() and return JS object?
@@ -965,8 +974,45 @@
 //
 // ---------- Transformations ------------
 // Odata spec: http://docs.oasis-open.org/odata/odata-data-aggregation-ext/v4.0/odata-data-aggregation-ext-v4.0.html
-
-  trafo
+  
+    transformations
+    = mainTransformation:transformation additionalTransformation:("/" t2:transformation {
+      return t2
+    })* {
+    	if(mainTransformation === undefined) return
+      additionalTransformation = Array.isArray(additionalTransformation) ? additionalTransformation : [additionalTransformation] 
+      // Loop through each element, add it to current level, if element is already part of result, increase level
+      for(let trafos of additionalTransformation) {
+        for(const transformation in trafos) {
+          if (transformation === 'where' && (mainTransformation.groupBy || mainTransformation.aggregate) && !mainTransformation.having) {
+            //When a group by or aggregate preceed a where, the where is a having
+            mainTransformation.having = trafos[transformation]
+          }
+          else if (transformation === 'limit' && mainTransformation.limit?.offset && trafos.limit.rows) {
+            //To avoid nesting in case first trafo is skip second is top, than they should be merged
+            //Inverse case first top than skip should not be nested as second skip will redcue the amount of returned items
+            mainTransformation.limit.rows = trafos.limit.rows
+          }
+          else if (transformation === 'limit' && mainTransformation.limit?.offset?.val && trafos.limit.offset?.val) {
+            //To avoid nesting in case of two subsequent skips as they can be merged
+            mainTransformation.limit.offset.val += trafos.limit.offset.val
+          } 
+          else if(
+          	mainTransformation[transformation] || 
+            //Case like aggregation follows with a / after groupBy - if they should be on the same level the aggregation is part of groupBy
+            (transformation === 'aggregate' && mainTransformation.groupBy && !trafos.groupBy)
+          ) {
+            mainTransformation = { apply: mainTransformation } 
+            mainTransformation[transformation] = trafos[transformation]
+          } else {
+            mainTransformation[transformation] = trafos[transformation]
+          }
+        }
+      }
+      return {apply: mainTransformation}
+    }
+    
+  transformation
     = (
       "aggregate" agg:aggregateTrafo{return agg} /
       "groupby" group:groupbyTrafo{return group} /
@@ -1174,6 +1220,9 @@
 
   word "a string"
     = $([^ \t\n()"&;]+)
+ 
+  simpleword "a string and/or number"
+    = $([a-zA-Z0-9]+)
 
   time "a time"
     = $([0-9][0-9]":"[0-9][0-9]":"[0-9][0-9])
@@ -1199,7 +1248,7 @@
     = s:$( [+-]? [0-9]+ ) { return parseInt(s) }
 
   identifier "an identifier"
-    = !bool !guid s:$([_a-zA-Z][_a-zA-Z0-9"."\u0041-\u005A\u0061-\u007A\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]*) { return s }
+    = !bool !guid s:$([_a-zA-Z][_a-zA-Z0-9"."\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0\u08A2-\u08AC\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097F\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191C\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA697\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA793\uA7A0-\uA7AA\uA7F8-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA80-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]*) { return s }
 
   guid "a guid"
     = $( hex16 hex16 "-"? hex16 "-"? hex16 "-"? hex16 "-"? hex16 hex16 hex16 )
@@ -1214,7 +1263,7 @@
     = $( [a-zA-Z0-9-"."_~!$'()*+,;=:@"/""?"]+ )
 
   binary "a binary" // > url-safe base64
-    = "binary'" s:$([a-zA-Z0-9-_]+ ("=="/"=")?) "'" { return cds.env.features.base64_binaries ? standardBase64(s) : Buffer.from(s, 'base64') }
+    = "binary'" s:$([a-zA-Z0-9_\-]+ ("=="/"=")?) "'" { return cds.env.features.base64_binaries ? standardBase64(s) : Buffer.from(s, 'base64') }
 
 //
 // ---------- Punctuation ----------