@sap/cds 7.8.2 → 7.9.1

package/libx/_runtime/common/utils/compareJson.js

@@ -0,0 +1,274 @@
+const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
+
+const _deepEqual = (val1, val2) => {
+  if (val1 && typeof val1 === 'object' && val2 && typeof val2 === 'object') {
+    for (const key in val1) {
+      if (!_deepEqual(val1[key], val2[key])) return false
+    }
+    return true
+  }
+  return val1 === val2
+}
+
+const _getCorrespondingEntryWithSameKeys = (source, entry, keys) => {
+  const idx = _getIdxCorrespondingEntryWithSameKeys(source, entry, keys)
+  return idx !== -1 ? source[idx] : undefined
+}
+
+const _getIdxCorrespondingEntryWithSameKeys = (source, entry, keys) =>
+  source.findIndex(sourceEntry => keys.every(key => _deepEqual(sourceEntry[key], entry[key])))
+
+const _getKeysOfEntity = entity =>
+  Object.keys(entity.keys).filter(key => !(key in DRAFT_COLUMNS_MAP) && !entity.elements[key].isAssociation)
+
+const _getCompositionsOfEntity = entity => Object.keys(entity.elements).filter(e => entity.elements[e].isComposition)
+
+const _createToBeDeletedEntries = (oldEntry, entity, keys, compositions) => {
+  const toBeDeletedEntry = {
+    _op: 'delete'
+  }
+
+  for (const prop in oldEntry) {
+    if (prop in DRAFT_COLUMNS_MAP) {
+      continue
+    }
+    if (keys.includes(prop)) {
+      toBeDeletedEntry[prop] = oldEntry[prop]
+    } else if (compositions.includes(prop) && oldEntry[prop]) {
+      toBeDeletedEntry[prop] = entity.elements[prop].is2one
+        ? _createToBeDeletedEntries(
+            oldEntry[prop],
+            entity.elements[prop]._target,
+            _getKeysOfEntity(entity.elements[prop]._target),
+            _getCompositionsOfEntity(entity.elements[prop]._target)
+          )
+        : oldEntry[prop].map(entry =>
+            _createToBeDeletedEntries(
+              entry,
+              entity.elements[prop]._target,
+              _getKeysOfEntity(entity.elements[prop]._target),
+              _getCompositionsOfEntity(entity.elements[prop]._target)
+            )
+          )
+    } else {
+      toBeDeletedEntry._old = toBeDeletedEntry._old || {}
+      toBeDeletedEntry._old[prop] = oldEntry[prop]
+    }
+  }
+
+  return toBeDeletedEntry
+}
+
+const _hasOpDeep = (entry, element) => {
+  const entryArray = Array.isArray(entry) ? entry : [entry]
+  for (const entry_ of entryArray) {
+    if (entry_._op) return true
+
+    if (element && element.isComposition) {
+      const target = element._target
+      for (const prop in entry_) {
+        if (_hasOpDeep(entry_[prop], target.elements[prop])) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+const _addCompositionsToResult = (result, entity, prop, newValue, oldValue, opts) => {
+  /*
+   * REVISIT: the current impl results in {} instead of keeping null for compo to one.
+   *          unfortunately, many follow-up errors occur (e.g., prop in null checks) if changed.
+   */
+  let composition
+  if (
+    newValue[prop] &&
+    typeof newValue[prop] === 'object' &&
+    !Array.isArray(newValue[prop]) &&
+    Object.keys(newValue[prop]).length === 0
+  ) {
+    composition = compareJsonDeep(entity.elements[prop]._target, undefined, oldValue && oldValue[prop], opts)
+  } else {
+    composition = compareJsonDeep(entity.elements[prop]._target, newValue[prop], oldValue && oldValue[prop], opts)
+  }
+  if (composition.some(c => _hasOpDeep(c, entity.elements[prop]))) {
+    result[prop] = entity.elements[prop].is2one ? composition[0] : composition
+  }
+}
+
+const _addPrimitiveValuesAndOperatorToResult = (result, prop, newValue, oldValue) => {
+  result[prop] = newValue[prop]
+
+  if (!result._op) {
+    result._op = oldValue ? 'update' : 'create'
+  }
+
+  if (result._op === 'update') {
+    result._old = result._old || {}
+    result._old[prop] = oldValue[prop]
+  }
+}
+
+const _addKeysToResult = (result, prop, newValue, oldValue) => {
+  result[prop] = newValue[prop]
+  if (!oldValue) {
+    result._op = 'create'
+  }
+}
+
+const _addToBeDeletedEntriesToResult = (results, entity, keys, newValues, oldValues) => {
+  // add to be deleted entries
+  for (const oldEntry of oldValues) {
+    const entry = _getCorrespondingEntryWithSameKeys(newValues, oldEntry, keys)
+
+    if (!entry) {
+      // prepare to be deleted (deep) entry without manipulating oldData
+      const toBeDeletedEntry = _createToBeDeletedEntries(oldEntry, entity, keys, _getCompositionsOfEntity(entity))
+      results.push(toBeDeletedEntry)
+    }
+  }
+}
+
+const _normalizeToArray = value => (Array.isArray(value) ? value : value === null ? [] : [value])
+
+const _isUnManaged = element => {
+  return element.on && !element._isSelfManaged
+}
+
+const _skip = (entity, prop) => entity.elements[prop]._target._hasPersistenceSkip
+
+const _skipToOne = (entity, prop) => {
+  return (
+    entity.elements[prop] && entity.elements[prop].is2one && _skip(entity, prop) && _isUnManaged(entity.elements[prop])
+  )
+}
+
+const _skipToMany = (entity, prop) => {
+  return entity.elements[prop] && entity.elements[prop].is2many && _skip(entity, prop)
+}
+
+// Returns all property names from the new entry and add missing managed elements
+const _propertiesAndManaged = (newEntry, entity) => {
+  return [
+    ...Object.getOwnPropertyNames(newEntry),
+    ...Object.keys(entity.elements).filter(
+      elementName => newEntry[elementName] === undefined && entity.elements[elementName]['@cds.on.update']
+    )
+  ]
+}
+
+const _iteratePropsInNewEntry = (newEntry, keys, result, oldEntry, entity, opts) => {
+  // On app-service layer, generated foreign keys are not enumerable,
+  // include them here too.
+  for (const prop of _propertiesAndManaged(newEntry, entity)) {
+    if (keys.includes(prop)) {
+      _addKeysToResult(result, prop, newEntry, oldEntry)
+      continue
+    }
+
+    // if value did not change --> ignored
+    if (newEntry[prop] === (oldEntry && oldEntry[prop]) || (opts.ignoreDraftColumns && prop in DRAFT_COLUMNS_MAP)) {
+      continue
+    }
+
+    if (_skipToMany(entity, prop)) {
+      continue
+    }
+
+    if (_skipToOne(entity, prop)) {
+      continue
+    }
+
+    if (entity.elements[prop] && entity.elements[prop].isComposition) {
+      _addCompositionsToResult(result, entity, prop, newEntry, oldEntry, opts)
+      continue
+    }
+
+    _addPrimitiveValuesAndOperatorToResult(result, prop, newEntry, oldEntry)
+  }
+}
+
+const compareJsonDeep = (entity, newValue = [], oldValue = [], opts) => {
+  const resultsArray = []
+  const keys = _getKeysOfEntity(entity)
+
+  // normalize input
+  const newValues = _normalizeToArray(newValue)
+  const oldValues = _normalizeToArray(oldValue)
+
+  // add to be created and to be updated entries
+  for (const newEntry of newValues) {
+    const result = {}
+    const oldEntry = _getCorrespondingEntryWithSameKeys(oldValues, newEntry, keys)
+    _iteratePropsInNewEntry(newEntry, keys, result, oldEntry, entity, opts)
+    resultsArray.push(result)
+  }
+
+  _addToBeDeletedEntriesToResult(resultsArray, entity, keys, newValues, oldValues)
+
+  return resultsArray
+}
+
+/**
+ * Compares newValue with oldValues in a deep fashion.
+ * Output format is newValue with additional administrative properties.
+ * - "_op" provides info about the CRUD action to perform
+ * - "_old" provides info about the current DB state
+ *
+ * Unchanged values are not part of the result.
+ *
+ * Output format is:
+ * {
+ *   _op: 'update',
+ *   _old: { orderedAt: 'DE' },
+ *   ID: 1,
+ *   orderedAt: 'EN',
+ *   items: [
+ *     {
+ *       _op: 'update',
+ *       _old: { amount: 7 },
+ *       ID: 7,
+ *       amount: 8
+ *     },
+ *     {
+ *       _op: 'create',
+ *       ID: 8,
+ *       amount: 8
+ *     },
+ *     {
+ *       _op: 'delete',
+ *       _old: {
+ *         amount: 6
+ *       },
+ *       ID: 6
+ *     }
+ *   ]
+ * }
+ *
+ *
+ * If there is no change in an UPDATE, result is an object containing only the keys of the entity.
+ *
+ * @example
+ * compareJson(csnEntity, [{ID: 1, col1: 'A'}], [{ID: 1, col1: 'B'}])
+ *
+ * @param oldValue
+ * @param {object} entity
+ * @param {Array | object} newValue
+ * @param {Array} oldValues
+ *
+ * @returns {Array}
+ */
+const compareJson = (newValue, oldValue, entity, opts = {}) => {
+  const options = Object.assign({ ignoreDraftColumns: false }, opts)
+  const result = compareJsonDeep(entity, newValue, oldValue, options)
+
+  // in case of batch insert, result is an array
+  // in all other cases it is an array with just one entry
+  return Array.isArray(newValue) ? result : result[0]
+}
+
+module.exports = {
+  compareJson
+}

package/libx/_runtime/common/utils/cqn2cqn4sql.js

@@ -14,7 +14,7 @@ const { getEntityFromPath } = require('../../common/utils/path')
 const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 const { addRefToWhereIfNecessary } = require('../../../odata/parse/afterburner')
 const { addAliasToExpression, PARENT_ALIAS, FOREIGN_ALIAS } = require('../../db/utils/generateAliases')
-const { getColumns } = require('../../cds-services/services/utils/columns')
+const { getColumns } = require('./columns')
 
 const _elementFromRef = (name, entity) => {
   if (!entity) return

package/libx/_runtime/{cds-services/services → common}/utils/differ.js

@@ -1,15 +1,15 @@
-const cds = require('../../../cds')
+const cds = require('../../cds')
 const { SELECT } = cds.ql
 
 const { compareJson } = require('./compareJson')
-const { selectDeepUpdateData } = require('../../../common/composition')
-const { ensureDraftsSuffix } = require('../../../fiori/utils/handler')
+const { selectDeepUpdateData } = require('../composition')
+const { ensureDraftsSuffix } = require('../../fiori/utils/handler')
 
-const { DRAFT_COLUMNS_MAP } = require('../../../common/constants/draft')
-const { cqn2cqn4sql, convertPathExpressionToWhere } = require('../../../common/utils/cqn2cqn4sql')
-const { revertData } = require('../../../common/utils/resolveView')
-const { removeIsActiveEntityRecursively } = require('../../../fiori/utils/where')
-const { enrichDataWithKeysFromWhere } = require('../../../common/utils/keys')
+const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
+const { cqn2cqn4sql, convertPathExpressionToWhere } = require('./cqn2cqn4sql')
+const { revertData } = require('./resolveView')
+const { removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
+const { enrichDataWithKeysFromWhere } = require('./keys')
 
 module.exports = class Differ {
   constructor(srv) {

package/libx/_runtime/common/utils/ensureIEEE754.js

@@ -0,0 +1,29 @@
+const getTemplate = require('./template')
+const templateProcessor = require('./templateProcessor')
+
+const _pick = element => {
+  return element._type in { 'cds.Decimal': 1, 'cds.Integer64': 1 }
+}
+
+const _processorFn = () => elementInfo => {
+  const { row, key } = elementInfo
+  if (typeof row?.[key] !== 'number') return
+  row[key] = `${row[key]}`
+}
+
+const ensureIEEE754 = (target, service, result) => {
+  const { model } = service
+  if (!target || !result || !model || !model.definitions[target.name]) return
+
+  const template = getTemplate('ensureIEEE754', service, target, { pick: _pick })
+  if (template.elements.size === 0) return
+
+  if (typeof result === 'object' && result != null) {
+    const processFn = _processorFn()
+    for (const row of Array.isArray(result) ? result : [result]) {
+      templateProcessor({ processFn, row, template })
+    }
+  }
+}
+
+module.exports = ensureIEEE754

package/libx/_runtime/common/utils/{postProcessing.js → postProcess.js}

@@ -89,6 +89,4 @@ const postProcess = (query, result, service, onlySelectAliases = false) => {
   return revertData(result, transition, service)
 }
 
-module.exports = {
-  postProcess
-}
+module.exports = postProcess

package/libx/_runtime/common/utils/resolveView.js

@@ -714,21 +714,6 @@ const resolveView = (query, model, service) => {
   return newQuery
 }
 
-/**
- * Restores the link of req.data and req.query in case req.query was overwritten.
- * Only applicable for UPDATEs and INSERTs.
- *
- * @param {*} req
- */
-const restoreLink = req => {
-  if (req.query.INSERT?.entries) {
-    if (Array.isArray(req.query.INSERT.entries)) req.data = req.query.INSERT.entries[0]
-    else req.data = req.query.INSERT.entries
-  } else if (req.query.UPDATE?.data) {
-    req.data = req.query.UPDATE.data
-  }
-}
-
 /**
  * Retrieves the actual query target by evaluating the created transitions.
  * @param {*} q - the resolved query
@@ -753,6 +738,5 @@ module.exports = {
   getDBTable,
   resolveView,
   getTransition,
-  restoreLink,
   revertData
 }

package/libx/_runtime/common/utils/rewriteAsterisks.js

@@ -42,7 +42,7 @@ const _resolveTarget = (ref, target) => {
   const element = target.elements[_ref]
   if (element) return element._target
 
-  throw cds.error(`Navigation property '${_ref}' is not defined in '${target.name}'`, { code: 400 })
+  throw cds.error(`Navigation property "${_ref}" is not defined in ${target.name}`, { code: 400 })
 }
 
 const rewriteExpandAsterisk = (columns, target) => {

package/libx/_runtime/common/utils/search2cqn4sql.js

@@ -1,4 +1,4 @@
-const { computeColumnsToBeSearched } = require('../../../../libx/_runtime/cds-services/services/utils/columns')
+const { computeColumnsToBeSearched } = require('./columns')
 const searchToLike = require('./searchToLike')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
 

package/libx/_runtime/common/utils/streamProp.js

@@ -3,7 +3,9 @@ const { ensureNoDraftsSuffix, ensureUnlocalized } = require('../../fiori/utils/h
 const { isDuplicate } = require('./rewriteAsterisks')
 
 const _addColumn = (name, type, columns, url) => {
+  // we do not want to return these additional odata properties with new adapter
   if (cds.env.features.odata_new_adapter) return
+
   if (typeof type === 'object') {
     let mType = type['='].replaceAll(/\./g, '_')
     const ref = {
@@ -27,6 +29,7 @@ const _addColumn = (name, type, columns, url) => {
 
 const _addColumns = (target, columns) => {
   if (cds.env.features.odata_new_adapter) return
+
   for (const k in target.elements) {
     const el = target.elements[k]
     if (el['@Core.MediaType']) {
@@ -35,6 +38,7 @@ const _addColumns = (target, columns) => {
   }
 }
 
+// eslint-disable-next-line complexity
 const handleStreamProperties = (target, columns, model) => {
   if (!target || !model || !columns) return
 
@@ -44,11 +48,14 @@ const handleStreamProperties = (target, columns, model) => {
     const name = col.ref && col.ref[col.ref.length - 1]
     const element = name && target.elements[name]
     const type = element && element.type
-    const mediaType = element && element['@Core.MediaType']
+    const mediaType = element?.['@Core.MediaType']
+
+    // new adapter handles urls correctly and just returns them as they are, okra handles them wrongly due to wrong EDM generation by compiler
+    const ignoreMediaType = cds.env.features.odata_new_adapter && mediaType && element['@Core.IsURL']
 
     if (col === '*') {
       _addColumns(target, columns)
-    } else if (col.ref && (type === 'cds.LargeBinary' || mediaType)) {
+    } else if (col.ref && (type === 'cds.LargeBinary' || (mediaType && !ignoreMediaType))) {
       if (mediaType) {
         _addColumn(name, mediaType, columns, element['@Core.IsURL'])
         columns.splice(index, 1)

package/libx/_runtime/common/utils/ucsn.js

@@ -75,7 +75,7 @@ const _cleanup = (row, definition, cleanupNull, cleanupStruct, errors, prefix =
         _cleanup(row[key], definition, cleanupNull, cleanupStruct, errors, [...prefix, key])
       } else {
         if (errors) {
-          errors.push(getError(400, 'Property ' + key + ' does not exist in ' + definition.name))
+          errors.push(getError(400, `Property "${key}" does not exist in ${definition.name}`))
         }
         delete row[key]
       }

package/libx/_runtime/db/expand/expandCQNToJoin.js

@@ -1024,7 +1024,7 @@ class JoinCQNFromExpanded {
     // Add table alias or name to handle cases, where joined tables have same column names
     if (this._isElement(column.ref, entity)) {
       const alias = tableAlias || ensureNoDraftsSuffix(entity.name)
-      aliasedElement.ref = alias ? [alias, column.ref[0]] : [column.ref[0]]
+      aliasedElement.ref = alias ? [alias, ...column.ref] : [...column.ref]
     }
 
     if (skipMapping) return aliasedElement
@@ -1050,8 +1050,10 @@ class JoinCQNFromExpanded {
   }
 
   _isElement(ref, entity) {
-    if (!ref || ref.length !== 1) return false
-
+    if (!ref) return false
+    if (ref.length > 1) {
+      return entity.elements[ref[0]]?.isAssociation
+    }
     // Normal element
     if (entity.elements[ref[0]]) return true
 

package/libx/_runtime/db/generic/rewrite.js

@@ -1,16 +1,13 @@
 const cds = require('../../cds')
 const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
 const { generateAliases } = require('../utils/generateAliases')
-const { restoreLink } = require('../../common/utils/resolveView')
 
-const _isLinked = req => {
+const _restoreLink = req => {
   if (req.query.INSERT?.entries) {
-    if (Array.isArray(req.query.INSERT.entries)) return req.data === req.query.INSERT.entries[0]
-    return req.data === req.query.INSERT.entries
+    return (req.data = Array.isArray(req.query.INSERT.entries) ? req.query.INSERT.entries[0] : req.query.INSERT.entries)
   }
-
   if (req.query.UPDATE?.data) {
-    return req.data === req.query.UPDATE.data
+    return (req.data = req.query.UPDATE.data)
   }
 }
 
@@ -26,19 +23,16 @@ function handler(req) {
     return
   }
 
-  const streaming = cds.env.features.stream_compat && req.query._streaming
-
-  // for restore link to req.data
-  const linked = _isLinked(req)
+  const _streaming = cds.env.features.stream_compat && req.query._streaming
 
   // convert to sql cqn
   req.query = cqn2cqn4sql(req.query, this.model, { service: this })
 
-  // REVISIT: should not be necessary
   // restore link to req.data
-  if (linked) restoreLink(req)
+  _restoreLink(req)
+
+  if (_streaming) req.query._streaming = _streaming
 
-  if (cds.env.features.stream_compat && streaming) req.query._streaming = streaming
   generateAliases(req.query)
 }
 

package/libx/_runtime/fiori/generic/activate.js

@@ -10,7 +10,7 @@ const {
 } = require('../utils/handler')
 const { readAndDeleteKeywords, isActiveEntityRequested, getKeyData } = require('../utils/where')
 const { isDraftRootEntity } = require('../../fiori/utils/csn')
-const { getColumns } = require('../../cds-services/services/utils/columns')
+const { getColumns } = require('../../common/utils/columns')
 const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 const _getRootCQN = (context, requestActiveData) => {

package/libx/_runtime/fiori/generic/edit.js

@@ -3,7 +3,7 @@ const getLockInfo = require('../utils/lockInfo')
 const { INSERT, SELECT, DELETE } = cds.ql
 
 const { getCompositionTree } = require('../../common/composition')
-const { getColumns } = require('../../cds-services/services/utils/columns')
+const { getColumns } = require('../../common/utils/columns')
 const { draftIsLocked, ensureDraftsSuffix, ensureNoDraftsSuffix, getSubCQNs } = require('../utils/handler')
 const { isActiveEntityRequested } = require('../utils/where')
 

package/libx/_runtime/fiori/generic/prepare.js

@@ -3,7 +3,7 @@ const { SELECT } = cds.ql
 
 const { isActiveEntityRequested } = require('../utils/where')
 const { ensureDraftsSuffix, ensureNoDraftsSuffix } = require('../utils/handler')
-const { getColumns } = require('../../cds-services/services/utils/columns')
+const { getColumns } = require('../../common/utils/columns')
 
 /**
  * Generic Handler for PreparationAction requests.