@sap/cds 5.8.4 → 5.9.0

package/libx/common/utils/ucsn.js

@@ -0,0 +1,109 @@
+const cds = require('../../_runtime/cds')
+const getTemplate = require('../../_runtime/common/utils/template')
+const templateProcessor = require('../../_runtime/common/utils/templateProcessor')
+const IS_PROXY = Symbol('flat2structProxy')
+
+const proxifyIfFlattened = (definition, payload) => {
+  if (!definition || !definition._flat2struct || payload == null || payload[IS_PROXY]) return payload
+  return Object.setPrototypeOf(
+    payload,
+    new Proxy(
+      {},
+      {
+        get: function (_, k, cur) {
+          if (k === IS_PROXY) return true
+          if (!definition._flat2struct[k]) return Reflect.get(...arguments)
+          const segments = definition._flat2struct[k]
+          for (let i = 0; i < segments.length - 1; i++) {
+            cur = cur[segments[i]]
+            if (!cur) return cur
+          }
+          return cur[segments[segments.length - 1]]
+        },
+        set: function (_, k, v, o) {
+          let cur = o
+          if (definition._flat2struct[k]) {
+            const segments = definition._flat2struct[k]
+            for (let i = 0; i < segments.length - 1; i++) {
+              if (!cur[segments[i]]) {
+                cur[segments[i]] = {}
+              }
+              cur = cur[segments[i]]
+            }
+            cur[segments[segments.length - 1]] = v
+          } else if (k === IS_PROXY) {
+            // do nothing
+          } else {
+            Reflect.set(...arguments)
+          }
+          return o
+        }
+      }
+    )
+  )
+}
+
+const _picker = element => {
+  if (Array.isArray(element)) return { category: 'flat leaf' }
+  if (element.isAssociation) return { category: 'node' }
+}
+
+const _processor = ({ row, key, plain: { category }, element }) => {
+  if (!(key in row)) return
+  if (category === 'node') {
+    row[key] = Array.isArray(row[key])
+      ? row[key].map(data => proxifyIfFlattened(element._target, data))
+      : proxifyIfFlattened(element._target, row[key])
+  } else if (category === 'flat leaf') {
+    const data = row[key]
+    delete row[key]
+    row[key] = data
+  }
+}
+
+const _cleanup = (row, definition, cleanupNull) => {
+  if (!row || !definition) return
+  const elements = definition.elements || definition.params
+  for (const key of Object.keys(row)) {
+    const element = elements[key]
+    if (!element) {
+      if (!definition['@open']) delete row[key]
+      continue
+    }
+    if (!row[key]) continue
+    if (element.isAssociation) {
+      if (element.is2many) {
+        for (const r of row[key]) {
+          _cleanup(r, element._target, cleanupNull)
+        }
+      } else {
+        _cleanup(row[key], element._target, cleanupNull)
+      }
+    } else if (element.elements) {
+      _cleanup(row[key], element, cleanupNull)
+      if (cleanupNull && Object.values(row[key]).every(v => v == null)) row[key] = null
+    }
+  }
+}
+
+function convertStructured(service, definition, data, { cleanupNull = false } = {}) {
+  if (!definition) return
+  // REVISIT check `structs` mode only for now as uCSN is not yet available
+  const flatAccess = cds.env.features.compat_flat_access
+  const template = getTemplate('universal-input', service, definition, { pick: _picker, flatAccess })
+  const arrayData = Array.isArray(data) ? data : [data]
+  if (template && template.elements.size) {
+    for (let i = 0; i < arrayData.length; i++) {
+      const row = proxifyIfFlattened(definition, arrayData[i])
+      templateProcessor({ processFn: _processor, row, template, pathOptions: { path: [] } })
+    }
+  }
+  for (const row of arrayData) {
+    _cleanup(row, definition, cleanupNull)
+  }
+}
+
+module.exports = {
+  convertStructured,
+  proxifyIfFlattened
+}

package/libx/gql/resolvers/crud/update.js

@@ -29,6 +29,11 @@ module.exports = async (service, entityFQN, selection) => {
     cds.context = tx
     // read needs to be done before the update, otherwise the where clause might become invalid (case that properties in where clause are updated by the mutation)
     resultBeforeUpdate = await tx.run(queryBeforeUpdate)
+
+    if (resultBeforeUpdate.length === 0) {
+      return []
+    }
+
     return tx.run(query)
   })
 

package/libx/gql/resolvers/parse/ast2cqn/columns.js

@@ -14,7 +14,9 @@ const astToColumns = selections => {
     }
 
     if (selection.selectionSet && selection.selectionSet.selections) {
-      column.expand = astToColumns(selection.selectionSet.selections)
+      const columns = astToColumns(selection.selectionSet.selections)
+      // columns is empty if only __typename was selected (which was filtered out in the enriched AST)
+      column.expand = columns.length > 0 ? columns : ['*']
     }
 
     const filter = getArgumentByName(selection.arguments, ARGUMENT.FILTER)

package/libx/gql/schema/typeDefMap.js

@@ -30,8 +30,8 @@ const servicesToTypeDefMap = services => {
           // TODO structured types
           continue
         } else {
-          if (CDS_TO_GRAPHQL_TYPES[ele.type]) {
-            def[ele.name] = CDS_TO_GRAPHQL_TYPES[ele.type]
+          if (CDS_TO_GRAPHQL_TYPES[ele._type]) {
+            def[ele.name] = CDS_TO_GRAPHQL_TYPES[ele._type]
           }
           // TODO aspects
         }

package/libx/odata/afterburner.js

@@ -3,10 +3,20 @@ const cds = require('../_runtime/cds')
 const { where2obj } = require('../_runtime/common/utils/cqn')
 const { findCsnTargetFor } = require('../_runtime/common/utils/csn')
 
-const _addKeysDeep = (keys, keysCollector) => {
+const _addKeysDeep = (keys, keysCollector, ignoreManagedBacklinks) => {
   for (const keyName in keys) {
     const key = keys[keyName]
-    if (key.type === 'cds.Association' || key['@odata.foreignKey4'] === 'up_') continue
+    const foreignKey = key._foreignKey4
+    if (key.isAssociation || foreignKey === 'up_' || key['@cds.api.ignore'] === true) continue
+
+    if (ignoreManagedBacklinks && foreignKey) {
+      const navigationElement = keys[foreignKey]
+      if (!navigationElement.on && navigationElement._isBacklink) {
+        // skip navigation elements that are backlinks
+        continue
+      }
+    }
+
     if ('elements' in key) {
       _addKeysDeep(key.elements, keysCollector)
       continue
@@ -15,10 +25,10 @@ const _addKeysDeep = (keys, keysCollector) => {
   }
 }
 
-function _keysOf(entity) {
+function _keysOf(entity, ignoreManagedBacklinks) {
   if (!entity || !entity.keys) return
   const keysCollector = []
-  _addKeysDeep(entity.keys, keysCollector)
+  _addKeysDeep(entity.keys, keysCollector, ignoreManagedBacklinks)
   return keysCollector
 }
 
@@ -31,18 +41,47 @@ function _getDefinition(definition, name, namespace) {
   )
 }
 
+function _resolveAliasInParams(params, entity) {
+  if (!entity._alias2ref) return
+  const paramKeys = Object.keys(params)
+  for (const paramKey of paramKeys) {
+    if (entity._alias2ref[paramKey]) {
+      params[entity._alias2ref[paramKey].join('_')] = params[paramKey]
+      params[paramKey] = undefined
+    }
+  }
+}
+
 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
+  for (const w of where) {
+    if (!w.ref || w.ref.length > 1 || entity.keys[w.ref[0]]) continue
+    w.ref = entity._alias2ref[w.ref[0]] || w.ref
+  }
+}
+
+function _addDefaultParams(ref, view) {
+  const params = view.params
+  const defaults = params && Object.values(params).filter(p => p.default)
+  if (defaults && defaults.length > 0) {
+    if (!ref.where) ref.where = []
+    for (const def of defaults) {
+      if (ref.where.find(e => e.ref && e.ref[0] === def.name)) {
+        continue
+      }
+      if (ref.where.length > 0) ref.where.push('and')
+      ref.where.push({ ref: [def.name] }, '=', { val: def.default.val })
+    }
   }
 }
 
 // case: single key without name, e.g., Foo(1)
 function addRefToWhereIfNecessary(where, entity) {
   if (!where || where.length !== 1) return 0
-  const keys = _keysOf(entity)
+
+  const isView = !!entity.params
+
+  const keys = isView ? Object.keys(entity.params) : _keysOf(entity)
   if (keys.length !== 1) return 0
   where.unshift(...[{ ref: [keys[0]] }, '='])
   return 1
@@ -64,13 +103,14 @@ function _processSegments(cqn, model, namespace) {
 
     if (incompleteKeys) {
       // > key
-      keys = keys || _keysOf(current)
-      const key = keys[keyCount++]
+      keys = keys || _keysOf(current, !cds.env.features.rest_new_adapter && !cds.env.features.rest_new_parser) // if odata skip backlinks as key as they are used from structure
+      let 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')
+
       if (ref[i].id) {
         // > fix case key value parsed to collection with filter
         const val = `${ref[i].id}(${Object.keys(params)
@@ -78,7 +118,7 @@ function _processSegments(cqn, model, namespace) {
           .join(',')})`
         base.where.push({ ref: [key] }, '=', { val })
       } else {
-        base.where.push({ ref: [key] }, '=', { val: element.type === 'cds.Integer' ? Number(seg) : seg })
+        base.where.push({ ref: [key] }, '=', { val: element._type === 'cds.Integer' ? Number(seg) : seg })
       }
       ref[i] = null
       ref[i - keyCount] = base
@@ -95,13 +135,40 @@ function _processSegments(cqn, model, namespace) {
       // REVISIT: 404 or 400?
       if (!current) cds.error(`Invalid resource path "${path}"`, { code: 404 })
 
-      if (current.kind === 'entity') {
+      if (current.params && current.kind === 'entity') {
+        // > View with params
+        if (ref[i].where) {
+          keyCount += addRefToWhereIfNecessary(ref[i].where, current)
+          _resolveAliasInWhere(ref[i].where, current)
+          _resolveAliasInParams(params, current)
+        }
+
+        _addDefaultParams(ref[i], current)
+        if ((!params || !Object.keys(params).length) && ref[i].where) params = where2obj(ref[i].where)
+
+        _checkAllKeysProvided(params, current)
+
+        ref[i].args = {}
+        for (let j = 0; j < ref[i].where.length; j++) {
+          const w = ref[i].where[j]
+          if (w === 'and' || !w.ref) continue
+          ref[i].args[w.ref[0]] = ref[i].where[j + 2]
+          j += 2
+        }
+        ref[i].where = undefined
+        if (ref[i + 1] !== 'Set') {
+          // /Set is missing
+          throw new Error(`Incorrect call to a view with parameter "${current.name}"`)
+        }
+        ref[++i] = null
+      } else 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)
+          _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)
           _checkAllKeysProvided(params, current)
@@ -114,7 +181,7 @@ function _processSegments(cqn, model, namespace) {
         }
         ref[i] = { operation: current.name }
         if (params) ref[i].args = params
-        if (current.returns && current.returns.type) one = true
+        if (current.returns && current.returns._type) one = true
       } else if (current.isAssociation) {
         // > navigation
         one = !!(current.is2one || ref[i].where)
@@ -161,11 +228,38 @@ function _processSegments(cqn, model, namespace) {
 const _resolveFrom = from => (from.SELECT ? _resolveFrom(from.SELECT.from) : from)
 
 const _checkAllKeysProvided = (params, entity) => {
-  const keysOfEntity = _keysOf(entity)
+  let keysOfEntity
+  const isView = !!entity.params
+  if (isView) {
+    // view with params
+    if (params === undefined) {
+      throw new Error(`Incorrect call to a view with parameter "${entity.name}"`)
+    } else if (Object.keys(params).length === 0) {
+      throw new Error('KEY_EXPECTED')
+    }
+
+    keysOfEntity = Object.keys(entity.params)
+  } else {
+    keysOfEntity = _keysOf(entity)
+  }
+
   if (!keysOfEntity) return
   for (const keyOfEntity of keysOfEntity) {
-    if (!(keyOfEntity in params))
-      throw Object.assign(new Error(`Key "${keyOfEntity}" is missing for entity "${entity.name}"`), { status: 400 })
+    if (!(keyOfEntity in params)) {
+      if (isView && entity.params[keyOfEntity].default) {
+        // will be added later?
+        continue
+      }
+
+      throw Object.assign(
+        new Error(
+          `${isView ? 'Parameter' : 'Key'} "${keyOfEntity}" is missing for ${isView ? 'view' : 'entity'} "${
+            entity.name
+          }"`
+        ),
+        { status: 400 }
+      )
+    }
   }
 }
 

package/libx/odata/grammar.pegjs

@@ -184,7 +184,15 @@
     / rv:$("$ref"/"$value") {return !TECHNICAL_OPTS.includes(rv) && {from: {ref: [rv]}}}
     / head:(
       (identifier filter:(OPEN CLOSE/OPEN args CLOSE)? !segment) / val:segment{return [val]}
-    ) tail:( '/' p:path {return p} )? {
+    )? tail:((s:"/" {return s;}) path?)? {
+      tail = tail && tail[1]
+      if (!head && !tail) {
+        return {from: {ref: ['']}}
+      } else if (!head && tail && tail.from) {
+        tail.from.ref.unshift('')
+        return tail
+      } 
+
       const [id, filter] = head
       // minimal: val also as path segment
       const ref = []

package/libx/odata/parseToCqn.js

@@ -0,0 +1,39 @@
+const cds = require('../../lib')
+
+module.exports = (component, service, target, data, odataReq, upsert) => {
+  let query = cds.odata.parse(odataReq, { service })
+
+  const _target = query.SELECT && query.SELECT.from
+
+  const {
+    SELECT: { one }
+  } = query
+
+  switch (component) {
+    case 'CREATE':
+      // create
+      // error in cases like `POST Books(1)` i.e. `POST` with navigation to single entity
+      if (one && !upsert) cds.error('POST not allowed on entity', { code: 400 })
+      return INSERT.into(_target).entries(data)
+    case 'DELETE':
+      if (!one) cds.error('DELETE not allowed on collection', { code: 400 })
+
+      // eslint-disable-next-line no-case-declarations
+      const last = _target.ref && _target.ref[_target.ref.length - 1]
+      if (target.elements[last]) {
+        // delete simple property
+        const ref = { ref: _target.ref.slice(0, _target.ref.length - 1) }
+        return UPDATE(ref).data({ [_target.ref[_target.ref.length - 1]]: null })
+      } else {
+        return DELETE.from(_target)
+      }
+    case 'UPDATE':
+      // eslint-disable-next-line no-throw-literal
+      if (!one) throw { statusCode: 400, code: '400', message: `INVALID_${odataReq.getMethod()}` }
+      return UPDATE(_target).data(data)
+    case 'READ':
+      return query
+    default:
+      return {}
+  }
+}