@sap/cds 5.6.1 → 5.7.1

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

@@ -11,15 +11,27 @@ const { isAsteriskColumn } = require('../../common/utils/rewriteAsterisks')
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
 const TO_MANY = Symbol.for('sap.cds.toMany')
 const TO_ACTIVE = Symbol.for('sap.cds.toActive')
-
 const SKIP_MAPPING = Symbol.for('sap.cds.skipMapping')
 const IDENTIFIER = Symbol.for('sap.cds.identifier')
 const IS_ACTIVE = Symbol.for('sap.cds.isActive')
 const IS_UNION_DRAFT = Symbol.for('sap.cds.isUnionDraft')
+
 const { DRAFT_COLUMNS } = require('../../common/constants/draft')
 
 const { getCQNUnionFrom } = require('../../common/utils/union')
 
+function getCqnCopy(readToOneCQN) {
+  const readToOneCQNCopy = JSON.parse(JSON.stringify(readToOneCQN))
+  if (readToOneCQN[GET_KEY_VALUE] !== undefined) readToOneCQNCopy[GET_KEY_VALUE] = readToOneCQN[GET_KEY_VALUE]
+  if (readToOneCQN[TO_MANY] !== undefined) readToOneCQNCopy[TO_MANY] = readToOneCQN[TO_MANY]
+  if (readToOneCQN[TO_ACTIVE] !== undefined) readToOneCQNCopy[TO_ACTIVE] = readToOneCQN[TO_ACTIVE]
+  if (readToOneCQN[SKIP_MAPPING] !== undefined) readToOneCQNCopy[SKIP_MAPPING] = readToOneCQN[SKIP_MAPPING]
+  if (readToOneCQN[IDENTIFIER] !== undefined) readToOneCQNCopy[IDENTIFIER] = readToOneCQN[IDENTIFIER]
+  if (readToOneCQN[IS_ACTIVE] !== undefined) readToOneCQNCopy[IS_ACTIVE] = readToOneCQN[IS_ACTIVE]
+  if (readToOneCQN[IS_UNION_DRAFT] !== undefined) readToOneCQNCopy[IS_UNION_DRAFT] = readToOneCQN[IS_UNION_DRAFT]
+  return readToOneCQNCopy
+}
+
 class JoinCQNFromExpanded {
   constructor(cqn, csn, locale) {
     this._SELECT = Object.assign({}, cqn.SELECT)
@@ -39,12 +51,8 @@ class JoinCQNFromExpanded {
    * @returns {this}
    */
   buildJoinQueries() {
-    const unionTableRef = this._getUnionTable(this._SELECT)
     // side effect: this_aliases is set
-    const aliases = this._getTableAlias(this._SELECT, [], unionTableRef && unionTableRef.table)
-
-    // Add table aliases to all refs in where part obtained from annotations
-    this._adaptAliasForWhere(this._SELECT.where)
+    const aliases = this._getTableAlias(this._SELECT, [])
 
     // Update elements at WHERE, so there are no issues with ambiguity
     this._adaptWhereOrderBy(this._SELECT, aliases)
@@ -91,16 +99,16 @@ class JoinCQNFromExpanded {
    * @private
    */
   _createJoinCQNFromExpanded(SELECT, toManyTree, defaultLanguage) {
-    const unionArgs = SELECT.from.args
-    const isJoinOfTwoUnions = unionArgs && unionArgs.every(a => a.SELECT)
+    const joinArgs = SELECT.from.args
+    const isJoinOfTwoSelects = joinArgs && joinArgs.every(a => a.SELECT)
 
     const unionTableRef = this._getUnionTable(SELECT)
     const unionTable = unionTableRef && unionTableRef.table
-    const tableAlias = this._getTableAlias(SELECT, toManyTree, unionTable)
+    const tableAlias = this._getTableAlias(SELECT, toManyTree)
 
-    const readToOneCQN = this._getReadToOneCQN(SELECT, isJoinOfTwoUnions ? 'filterExpand' : tableAlias)
+    const readToOneCQN = this._getReadToOneCQN(SELECT, isJoinOfTwoSelects ? 'filterExpand' : tableAlias)
 
-    if (isJoinOfTwoUnions) {
+    if (isJoinOfTwoSelects) {
       // mappings
       const mappings = this._getMappingObject(toManyTree)
       const prefix = `${tableAlias}_`
@@ -110,7 +118,7 @@ class JoinCQNFromExpanded {
           mappings[c.as.replace(prefix, '')] = c.as
         })
       // expand to one
-      const entity = this._csn.definitions[unionArgs[0].SELECT.from.SET.args[1].SELECT.from.ref[0]]
+      const entity = this._csn.definitions[joinArgs[0].SELECT.from.SET.args[1].SELECT.from.ref[0]]
       const givenColumns = readToOneCQN.columns
       readToOneCQN.columns = []
       this._expandedToFlat({ entity, givenColumns, readToOneCQN, tableAlias, toManyTree, defaultLanguage })
@@ -128,6 +136,9 @@ class JoinCQNFromExpanded {
       this._expandedToFlat({ entity, givenColumns, readToOneCQN, tableAlias, toManyTree, defaultLanguage })
     }
 
+    // brute force hack
+    readToOneCQN.columns = readToOneCQN.columns.filter(c => c.as !== 'filterExpand_IsActiveEntity')
+
     // Add at start, so that the deepest level is post processed first
     this.queries.push({
       SELECT: readToOneCQN,
@@ -146,11 +157,14 @@ class JoinCQNFromExpanded {
    * @returns {string}
    * @private
    */
-  _getTableAlias(SELECT, toManyTree, unionTable) {
-    return this._createAlias(toManyTree.length === 0 ? unionTable || this._getRef(SELECT).table : toManyTree.join(':'))
+  _getTableAlias(SELECT, toManyTree) {
+    return this._createAlias(toManyTree.length === 0 ? this._getRef(SELECT).table : toManyTree.join(':'))
   }
 
   _getRef(SELECT) {
+    const unionTableRef = this._getUnionTable(SELECT)
+    if (unionTableRef) return unionTableRef
+
     const table = Object.prototype.hasOwnProperty.call(SELECT.from, 'join')
       ? this._getRefFromJoin(SELECT.from.args)
       : SELECT.from
@@ -241,10 +255,18 @@ class JoinCQNFromExpanded {
       : column
   }
 
-  _adaptJoin(tableAlias, cqn, from) {
+  _adaptJoin(tableAlias, cqn, from, mapping = {}) {
     from.args = from.args.slice(0)
     if (Object.prototype.hasOwnProperty.call(from.args[0], 'join')) {
-      this._adaptJoin(tableAlias, cqn, from.args[0])
+      this._adaptJoin(tableAlias, cqn, from.args[0], mapping)
+      if (from.on) {
+        // we come here for SiblingEntity with expand
+        for (const originalIdentifier in mapping) {
+          from.on = from.on.map(column =>
+            this._adaptTableNameInColumn(column, originalIdentifier, mapping[originalIdentifier])
+          )
+        }
+      }
     } else {
       const index = from.args[0].ref ? 0 : from.args.length - 1
       const target = Object.assign({}, from.args[index], { as: tableAlias })
@@ -253,6 +275,7 @@ class JoinCQNFromExpanded {
       from.args[index] = target
       from.on = from.on.map(column => this._adaptTableNameInColumn(column, originalIdentifier, tableAlias))
       cqn.columns = cqn.columns.map(column => this._adaptTableNameInColumn(column, originalIdentifier, tableAlias))
+      mapping[originalIdentifier] = tableAlias
     }
   }
 
@@ -316,32 +339,6 @@ class JoinCQNFromExpanded {
     whereElement.ref && whereElement.ref.splice(0, 1, Object.values(this._aliases)[0])
   }
 
-  _adaptAliasForFrom(from) {
-    if (from.args) {
-      from.args.forEach(arg => {
-        this._adaptAliasForFrom(arg)
-      })
-    } else if (from.SELECT) {
-      this._adaptAliasForFrom(from.SELECT.from)
-      if (from.SELECT.where) {
-        this._adaptAliasForWhere(from.SELECT.where)
-      }
-    }
-  }
-
-  _adaptAliasForWhere(where) {
-    if (where) {
-      for (const whereElement of where) {
-        if (whereElement.SELECT) {
-          if (whereElement.SELECT.where) {
-            this._adaptAliasForWhere(whereElement.SELECT.where)
-          }
-          this._adaptAliasForFrom(whereElement.SELECT.from)
-        }
-      }
-    }
-  }
-
   _navigationNeedsAlias(element, { table } = {}) {
     const entity = this._csn.definitions[table]
     if (entity) {
@@ -362,9 +359,9 @@ class JoinCQNFromExpanded {
 
       if (element.ref.length === 1) {
         element.ref.unshift(tableAlias)
-      } else if (this._elementAliasNeedsReplacement(element, this._getUnionTable(cqn) || this._getRef(cqn))) {
+      } else if (this._elementAliasNeedsReplacement(element, this._getRef(cqn))) {
         element.ref[0] = tableAlias
-      } else if (this._navigationNeedsAlias(element, this._getUnionTable(cqn) || this._getRef(cqn))) {
+      } else if (this._navigationNeedsAlias(element, this._getRef(cqn))) {
         element.ref.unshift(tableAlias)
       }
 
@@ -377,7 +374,7 @@ class JoinCQNFromExpanded {
     } else if (element.SELECT && element.SELECT.where) {
       element = {
         SELECT: Object.assign({}, element.SELECT, {
-          where: this._adaptWhereSELECT(this._getUnionTable(cqn) || this._getRef(cqn), element.SELECT.where, tableAlias)
+          where: this._adaptWhereSELECT(this._getRef(cqn), element.SELECT.where, tableAlias)
         })
       }
     }
@@ -480,6 +477,8 @@ class JoinCQNFromExpanded {
     const toManyColumns = []
     const mappings = this._getMappingObject(toManyTree)
 
+    const readToOneCQNCopy = getCqnCopy(readToOneCQN)
+
     for (const column of givenColumns) {
       let navigation
       if (column.expand) {
@@ -523,7 +522,16 @@ class JoinCQNFromExpanded {
     }
 
     // only as second step handle expand to many, or else keys might still be unknown
-    this._toMany({ entity, readToOneCQN, tableAlias, toManyColumns, toManyTree, mappings, defaultLanguage })
+    this._toMany({
+      entity,
+      readToOneCQN,
+      tableAlias,
+      toManyColumns,
+      toManyTree,
+      mappings,
+      defaultLanguage,
+      readToOneCQNCopy
+    })
   }
 
   adjustOrderBy(orderBy, mappings, column, tableAlias) {
@@ -562,13 +570,15 @@ class JoinCQNFromExpanded {
     const on = []
     for (const key in entity._target.keys) {
       if (key !== 'IsActiveEntity') {
+        if (on.length) on.push('AND')
         on.push({ ref: [`${tableAlias}_drafts`, key] }, '=', { ref: [tableAlias, key] })
       }
     }
+
     return {
       args: [cqn, { ref: [draftTable], as: `${tableAlias}_drafts` }],
       join: 'left',
-      on: on
+      on: ['(', ...on, ')']
     }
   }
 
@@ -587,8 +597,8 @@ class JoinCQNFromExpanded {
     )
   }
 
-  _getTarget(entity, column) {
-    const navigation = getNavigationIfStruct(entity, column.ref)
+  _getTarget(entity, column, parentAlias) {
+    const navigation = getNavigationIfStruct(entity, column.ref[0] === parentAlias ? column.ref.slice(1) : column.ref)
     return (navigation && navigation.target) || column.ref[0]
   }
 
@@ -606,17 +616,19 @@ class JoinCQNFromExpanded {
    */
   // eslint-disable-next-line complexity
   _addJoinAndElements({ column, entity, readToOneCQN, toManyTree, parentAlias, defaultLanguage }) {
-    const extendedToManyTree = toManyTree.concat(column.ref)
+    const extendedToManyTree = toManyTree.concat(column.ref[0] === parentAlias ? column.ref.slice(1) : column.ref)
     const tableAlias = this._createAlias(extendedToManyTree.join(':'))
-    const target = this._getTarget(entity, column)
+    const target = this._getTarget(entity, column, parentAlias)
+
+    const name = column.ref[column.ref.length - 1]
+    const element = name && entity.elements[name]
 
     // if union always only expand with active, otherwise evaluate flag
     // if flag shows false, we check entity for associations to non draft
     const activeTableRequired =
       readToOneCQN[IS_UNION_DRAFT] ||
       readToOneCQN[IS_ACTIVE] ||
-      (entity.elements[column.ref[0]].type === 'cds.Association' &&
-        !entity.elements[column.ref[0]]['@odata.draft.enclosed']) ||
+      (element && element.type === 'cds.Association' && !element['@odata.draft.enclosed']) ||
       !this._csn.definitions[target]._isDraftEnabled
 
     const colTarget = target && ensureUnlocalized(target)
@@ -626,9 +638,7 @@ class JoinCQNFromExpanded {
       (colTarget && this._csn.definitions[colTarget] && this._csn.definitions[colTarget]['@cds.localized'] === false)
 
     const join =
-      column.ref[0] === 'DraftAdministrativeData' || !entity.elements[column.ref[0]].notNull || this._isDraft
-        ? 'left'
-        : 'inner'
+      column.ref[0] === 'DraftAdministrativeData' || !(element && element.notNull) || this._isDraft ? 'left' : 'inner'
 
     const args = [
       readToOneCQN.from.SET ? this._unionToSubQuery(readToOneCQN) : readToOneCQN.from,
@@ -669,11 +679,11 @@ class JoinCQNFromExpanded {
     }
 
     // special case of navigation to one requires additional LEFT JOIN and CASE for HasDraftEntity
-    const compToOne = this._isNavigationToOne(readToOneCQN[IS_ACTIVE], entity.elements[column.ref[0]])
+    const compToOne = this._isNavigationToOne(readToOneCQN[IS_ACTIVE], element)
     const index = column.expand.findIndex(col => col.ref && col.ref[col.ref.length - 1] === 'HasDraftEntity')
 
     if (compToOne && index !== -1) {
-      readToOneCQN.from = this._addJoinCompToOne(readToOneCQN.from, entity.elements[column.ref[0]], tableAlias)
+      readToOneCQN.from = this._addJoinCompToOne(readToOneCQN.from, element, tableAlias)
       if (activeTableRequired) {
         column.expand[index] = {
           xpr: [
@@ -823,7 +833,9 @@ class JoinCQNFromExpanded {
     const subSelectColumns = this._getSubSelectColumns(readToOneCQN)
 
     if (subSelectColumns.length === 0) {
-      return entity._relations[tableAlias === columns[0] ? columns.slice(1) : columns].join(tableAlias, parentAlias)
+      return entity._relations[
+        tableAlias === columns[0] || parentAlias === columns[0] ? columns.slice(1) : columns
+      ].join(tableAlias, parentAlias)
     }
 
     const aliases = this._getAliases(subSelectColumns)
@@ -957,7 +969,16 @@ class JoinCQNFromExpanded {
     return DRAFT_COLUMNS.includes(ref[0])
   }
 
-  _toMany({ entity, readToOneCQN, tableAlias, toManyColumns, toManyTree, mappings, defaultLanguage }) {
+  _toMany({
+    entity,
+    readToOneCQN,
+    tableAlias,
+    toManyColumns,
+    toManyTree,
+    mappings,
+    defaultLanguage,
+    readToOneCQNCopy
+  }) {
     if (toManyColumns.length === 0) {
       return
     }
@@ -968,7 +989,7 @@ class JoinCQNFromExpanded {
       const select = this._buildExpandedCQN({
         column,
         entity,
-        readToOneCQN,
+        readToOneCQN: readToOneCQNCopy,
         toManyTree,
         mappings,
         parentAlias,

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

@@ -1,8 +1,10 @@
 const { hasExpand, createJoinCQNFromExpanded } = require('./expandCQNToJoin')
 const rawToExpanded = require('./rawToExpanded')
+const expandV2 = require('./expand-v2')
 
 module.exports = {
   hasExpand,
   createJoinCQNFromExpanded,
-  rawToExpanded
+  rawToExpanded,
+  expandV2
 }

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

@@ -1,27 +1,14 @@
-// REVISIT: use templating mechanism (resp. results.metadata, once available) to make more efficient
-
 const { getEntityFromCQN } = require('../../common/utils/entityFromCqn')
+const getTemplate = require('../../common/utils/template')
+const templateProcessor = require('../../common/utils/templateProcessor')
 
-const _toArray = (result, elements) => {
-  // REVISIT: This is a very expensive loop in loop...
-  // and 100% overhead the results don't contain arrayed elements,
-  // and 100% of all currently existing stakeholder projects don't.
-  // but that's not that easy to fix -> see comment about results.metadata below
-  for (const row of result) {
-    for (const column in row) {
-      if (elements[column] === undefined || row[column] === undefined) continue
+const _pick = element => {
+  if (element.kind === 'element' && element.items) return 'arrayed'
+}
 
-      // .items marks arrayed element
-      if (elements[column].items) {
-        row[column] = JSON.parse(row[column])
-      } else if (elements[column].is2many) {
-        _toArray(row[column], elements[column]._target.elements)
-      } else if (elements[column].is2one) {
-        _toArray([row[column]], elements[column]._target.elements)
-      } else if (elements[column].elements) {
-        _toArray([row[column]], elements[column].elements)
-      }
-    }
+const _processFn = ({ row, key, plain }) => {
+  if (plain === 'arrayed' && row && row[key] && (typeof row[key] === 'string' || Buffer.isBuffer(row[key]))) {
+    row[key] = JSON.parse(row[key])
   }
 }
 
@@ -35,12 +22,12 @@ const _toArray = (result, elements) => {
 module.exports = function (result, req) {
   if (!this.model) return
 
-  if (!Array.isArray(result)) result = [result]
-
-  // REVISIT: We need results.metadata to make that more efficient
-  // results.metadata ~= cds.infer(req.query).metadata
-  // REVISIT: No entity for sets/unions outside of common draft scenarios
   const entity = getEntityFromCQN(req, this)
   if (!entity) return
-  if (entity) _toArray(result, entity.elements)
+
+  const template = getTemplate('db-arrayed', this, entity, { pick: _pick })
+  if (template.elements.size === 0) return
+
+  for (const row of Array.isArray(result) ? result : [result])
+    templateProcessor({ processFn: _processFn, row, template })
 }

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

@@ -14,7 +14,7 @@ const cds = require('../../cds')
 const normalizeTimeData = require('../utils/normalizeTimeData')
 
 const { enrichDataWithKeysFromWhere } = require('../../common/utils/keys')
-const { propagateForeignKeys } = require('../../common/utils/propagateForeignKeys')
+const propagateForeignKeys = require('../utils/propagateForeignKeys')
 const getTemplate = require('../../common/utils/template')
 const templateProcessor = require('../../common/utils/templateProcessor')
 
@@ -25,12 +25,14 @@ const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 const _isManaged = (category, event) =>
   (category === '@cds.on.insert' && event === 'CREATE') || (category === '@cds.on.update' && event === 'UPDATE')
 
+const _shouldGenerateUUID = element => element.key && !DRAFT_COLUMNS_MAP[element.name] && element.type === 'cds.UUID'
+
 const _processComplexCategory = ({ row, key, val, category, req, element }) => {
   const categoryArgs = category.args
   category = category.category
 
   // propagate keys
-  if (category === 'propagateForeignKeys') {
+  if (category === 'propagateForeignKeys' && row[key]) {
     propagateForeignKeys(key, row, element._foreignKeys, element._isCompositionEffective)
     return
   }
@@ -73,6 +75,20 @@ const _processCategory = ({ category, row, key, element, val, req }) => {
     return
   }
 
+  if (category === 'comp2one') {
+    if (!val) return
+
+    for (const keyName in element._target.keys) {
+      const k = element._target.keys[keyName]
+      if (k.type === 'cds.Association' || k.name === 'IsActiveEntity') continue
+
+      if (k.type !== 'cds.UUID' && !(k.name in val)) {
+        req.error(400, 'ASSERT_NOT_NULL', key + '[' + k + ']', [key + '[' + k + ']'])
+        return
+      }
+    }
+  }
+
   // not null without default (for better error message)
   if (category === '!default' && val == null && req.event === 'CREATE') {
     req.error(400, 'ASSERT_NOT_NULL', key, [key])
@@ -101,12 +117,24 @@ const processorFn =
     }
   }
 
+const _isVirtualOrCalculated = element => {
+  if (element.virtual) return true
+  if (
+    element.parent &&
+    element.parent.projection &&
+    element.parent.projection.columns &&
+    element.parent.projection.columns.find(c => c.as === element.name && (c.xpr || c.val || c.func))
+  ) {
+    return true
+  }
+}
+
 // params: element, target, parent, templateElements
-const _pick = element => {
+const _pickCRUD = element => {
   // collect actions to apply
   const categories = []
 
-  if (element.virtual) {
+  if (_isVirtualOrCalculated(element)) {
     categories.push('virtual')
     return { categories } // > no need to continue
   }
@@ -136,22 +164,37 @@ const _pick = element => {
     categories.push('associationEffective')
   }
 
+  // REVISIT: element._foreignKeys.length seems to be a very broad check
   if (element.isAssociation && element._foreignKeys.length) {
     categories.push({ category: 'propagateForeignKeys' })
   }
 
-  // generate uuid
-  if (element.key && !DRAFT_COLUMNS_MAP[element.name] && element.type === 'cds.UUID') {
+  if (_shouldGenerateUUID(element)) {
     categories.push('uuid')
   }
 
+  if (element.isComposition && element.is2one) {
+    categories.push('comp2one')
+  }
+
   if (categories.length) return { categories }
 }
 
-const _pickVirtual = element => {
+const _pickDraft = element => {
   // collect actions to apply
   const categories = []
+
   if (element.virtual) categories.push('virtual')
+
+  // REVISIT: element._foreignKeys.length seems to be a very broad check
+  if (element.isAssociation && element._foreignKeys.length) {
+    categories.push({ category: 'propagateForeignKeys' })
+  }
+
+  if (_shouldGenerateUUID(element)) {
+    categories.push('uuid')
+  }
+
   if (categories.length) return { categories }
 }
 
@@ -174,10 +217,9 @@ function _handler(req) {
 
   let template
   if (draft) {
-    // draft -> filter virtual only
-    template = getTemplate('db-virtual', this, target, { pick: _pickVirtual })
+    template = getTemplate('db-input-draft', this, target, { pick: _pickDraft })
   } else {
-    template = getTemplate('db-input', this, target, { pick: _pick })
+    template = getTemplate('db-input-crud', this, target, { pick: _pickCRUD })
   }
 
   if (template.elements.size === 0) return