@cap-js/db-service 1.6.1 → 1.6.3

package/CHANGELOG.md

@@ -4,6 +4,27 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.6.3](https://github.com/cap-js/cds-dbs/compare/db-service-v1.6.2...db-service-v1.6.3) (2024-02-20)
+
+
+### Fixed
+
+* **`cqn4sql`:** be robust against `$self.<element>;` references ([#471](https://github.com/cap-js/cds-dbs/issues/471)) ([2921b0e](https://github.com/cap-js/cds-dbs/commit/2921b0e8ada33b172a001d89904893268e751efd))
+* **`infer`:** Always use srv.model ([#451](https://github.com/cap-js/cds-dbs/issues/451)) ([41cf4a2](https://github.com/cap-js/cds-dbs/commit/41cf4a24cf2f5e2411be0dc647af6eb628a6d312))
+* Throw 'new Error' instead of string on $search with multiple words ([#472](https://github.com/cap-js/cds-dbs/issues/472)) ([51be94d](https://github.com/cap-js/cds-dbs/commit/51be94d2333b4a4007f354c805d1b974b19d6d2d))
+
+## [1.6.2](https://github.com/cap-js/cds-dbs/compare/db-service-v1.6.1...db-service-v1.6.2) (2024-02-16)
+
+
+### Fixed
+
+* ** `infer`:** unique alias for scoped subqueries ([#465](https://github.com/cap-js/cds-dbs/issues/465)) ([5dbaa8e](https://github.com/cap-js/cds-dbs/commit/5dbaa8e414102ee1dd0d8f76058c9eeff899666e))
+* Allow only for array of arrays as data for plain SQL ([#449](https://github.com/cap-js/cds-dbs/issues/449)) ([22e1c43](https://github.com/cap-js/cds-dbs/commit/22e1c43c38709c6597be9e642619476338ef824a))
+* dont insert structured elements ([#461](https://github.com/cap-js/cds-dbs/issues/461)) ([f3f688d](https://github.com/cap-js/cds-dbs/commit/f3f688d6ef45f9d42690c13eaf88ab004aa86ff9))
+* ignore virtual keys in UPSERT([#463](https://github.com/cap-js/cds-dbs/issues/463)) ([49adbf3](https://github.com/cap-js/cds-dbs/commit/49adbf35f243d6365f84a8cf0193f028798aa366))
+* INSERT entries containing undefined values ([#453](https://github.com/cap-js/cds-dbs/issues/453)) ([d3aad75](https://github.com/cap-js/cds-dbs/commit/d3aad7580f45ccde8528ddfa261f81d155354574))
+* select without columns from unknown entity ([#466](https://github.com/cap-js/cds-dbs/issues/466)) ([eb857de](https://github.com/cap-js/cds-dbs/commit/eb857def41a89e9afe5e72686c3e55273c983b98))
+
 ## [1.6.1](https://github.com/cap-js/cds-dbs/compare/db-service-v1.6.0...db-service-v1.6.1) (2024-02-05)
 
 

package/lib/SQLService.js

@@ -36,7 +36,7 @@ class SQLService extends DatabaseService {
               return Object.assign(acc, obj)
             }, {}),
           )
-          const invalidColumns = columns.filter(c => !(c in elements))
+        const invalidColumns = columns.filter(c => !(c in elements))
 
         if (invalidColumns.length > 0) {
           cds.error(`STRICT MODE: Trying to ${kind} non existent columns (${invalidColumns})`)
@@ -114,7 +114,11 @@ class SQLService extends DatabaseService {
    * @type {Handler}
    */
   async onSELECT({ query, data }) {
-    query.SELECT.expand = 'root'
+    if (query.target && !query.target._unresolved) {
+      // Will return multiple rows with objects inside
+      query.SELECT.expand = 'root'
+    }
+
     const { sql, values, cqn } = this.cqn2sql(query, data)
     let ps = await this.prepare(sql)
     let rows = await ps.all(values)
@@ -245,7 +249,7 @@ class SQLService extends DatabaseService {
       DEBUG?.(query, data)
       const ps = await this.prepare(query)
       const exec = this.hasResults(query) ? d => ps.all(d) : d => ps.run(d)
-      if (Array.isArray(data) && typeof data[0] === 'object') return await Promise.all(data.map(exec))
+      if (Array.isArray(data) && Array.isArray(data[0])) return await Promise.all(data.map(exec))
       else return exec(data)
     } else return next()
   }

package/lib/cql-functions.js

@@ -21,7 +21,7 @@ const StandardFunctions = {
    * @returns {string}
    */
   search: function (ref, arg) {
-    if (!('val' in arg)) throw `Only single value arguments are allowed for $search`
+    if (!('val' in arg)) throw new Error(`Only single value arguments are allowed for $search`)
     const refs = ref.list || [ref],
       { toString } = ref
     return '(' + refs.map(ref2 => this.contains(this.tolower(toString(ref2)), this.tolower(arg))).join(' or ') + ')'

package/lib/cqn2sql.js

@@ -31,6 +31,7 @@ class CQN2SQLRenderer {
     this.context = srv?.context || cds.context // Using srv.context is required due to stakeholders doing unmanaged txs without cds.context being set
     this.class = new.target // for IntelliSense
     this.class._init() // is a noop for subsequent calls
+    this.model = srv?.model
   }
 
   static _add_mixins(aspect, mixins) {
@@ -94,6 +95,10 @@ class CQN2SQLRenderer {
     return q.target ? q : cds_infer(q)
   }
 
+  cqn4sql(q) {
+    return cqn4sql(q, this.model)
+  }
+
   // CREATE Statements ------------------------------------------------
 
   /**
@@ -109,7 +114,7 @@ class CQN2SQLRenderer {
     this.sql =
       !query || target['@cds.persistence.table']
         ? `CREATE TABLE ${name} ( ${this.CREATE_elements(target.elements)} )`
-        : `CREATE VIEW ${name} AS ${this.SELECT(cqn4sql(query))}`
+        : `CREATE VIEW ${name} AS ${this.SELECT(this.cqn4sql(query))}`
     this.values = []
     return
   }
@@ -479,10 +484,11 @@ class CQN2SQLRenderer {
 
           buffer += '"'
         } else {
+          if (val === undefined) continue
           if (elements[key]?.type in BINARY_TYPES) {
             val = transformBase64(val)
           }
-          buffer += `${keyJSON}${val === undefined ? 'null' : JSON.stringify(val)}`
+          buffer += `${keyJSON}${JSON.stringify(val)}`
         }
       }
       buffer += '}'
@@ -612,7 +618,7 @@ class CQN2SQLRenderer {
       c => c in elements && !elements[c].virtual && !elements[c].isAssociation,
     ))
     this.sql = `INSERT INTO ${entity}${alias ? ' as ' + this.quote(alias) : ''} (${columns}) ${this.SELECT(
-      cqn4sql(INSERT.as),
+      this.cqn4sql(INSERT.as),
     )}`
     this.entries = [this.values]
     return this.sql
@@ -650,7 +656,7 @@ class CQN2SQLRenderer {
     let sql = this.INSERT({ __proto__: q, INSERT: UPSERT })
     let keys = q.target?.keys
     if (!keys) return this.sql = sql
-    keys = Object.keys(keys).filter(k => !keys[k].isAssociation)
+    keys = Object.keys(keys).filter(k => !keys[k].isAssociation && !keys[k].virtual)
 
     let updateColumns = q.UPSERT.entries ? Object.keys(q.UPSERT.entries[0]) : this.columns
     updateColumns = updateColumns.filter(c => {
@@ -692,6 +698,7 @@ class CQN2SQLRenderer {
     function _add(data, sql4) {
       for (let c in data) {
         if (!elements || (c in elements && !elements[c].virtual)) {
+          if (cds.unfold && elements?.[c].is_struct) continue // skip structs from universal csn
           columns.push({ name: c, sql: sql4(data[c]) })
         }
       }
@@ -817,8 +824,8 @@ class CQN2SQLRenderer {
    */
   ref({ ref }) {
     switch (ref[0]) {
-      case '$now':  return this.func({ func: 'session_context', args: [{ val: '$now', param: false }] }) // REVISIT: why do we need param: false here?
-      case '$user': return this.func({ func: 'session_context', args: [{ val: '$user.'+ref[1]||'id', param: false }] }) // REVISIT: same here?
+      case '$now': return this.func({ func: 'session_context', args: [{ val: '$now', param: false }] }) // REVISIT: why do we need param: false here?
+      case '$user': return this.func({ func: 'session_context', args: [{ val: '$user.' + ref[1] || 'id', param: false }] }) // REVISIT: same here?
       default: return ref.map(r => this.quote(r)).join('.')
     }
   }
@@ -986,6 +993,6 @@ const _empty = a => !a || a.length === 0
  * @param {import('@sap/cds/apis/cqn').Query} q
  * @param {import('@sap/cds/apis/csn').CSN} m
  */
-module.exports = (q, m) => new CQN2SQLRenderer().render(cqn4sql(q, m), m)
+module.exports = (q, m) => new CQN2SQLRenderer({ model: m }).render(cqn4sql(q, m))
 module.exports.class = CQN2SQLRenderer
 module.exports.classDefinition = CQN2SQLRenderer // class is a reserved typescript word

package/lib/cqn4sql.js

@@ -43,7 +43,7 @@ const { pseudos } = require('./infer/pseudos')
  * @param {object} model
  * @returns {object} transformedQuery the transformed query
  */
-function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
+function cqn4sql(originalQuery, model) {
   const inferred = infer(originalQuery, model)
   if (originalQuery.SELECT?.from.args && !originalQuery.joinTree) return inferred
 
@@ -122,7 +122,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           primaryKey.list.push({ ref: [transformedFrom.as, k.name] })
         })
 
-        const transformedSubquery = cqn4sql(subquery)
+        const transformedSubquery = cqn4sql(subquery, model)
 
         // replace where condition of original query with the transformed subquery
         // correlate UPDATE / DELETE query with subquery by primary key matches
@@ -918,7 +918,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       if (q.SELECT.from.uniqueSubqueryAlias) return
       const last = q.SELECT.from.ref.at(-1)
       const uniqueSubqueryAlias = inferred.joinTree.addNextAvailableTableAlias(
-        getLastStringSegment(last.id||last),
+        getLastStringSegment(last.id || last),
         originalQuery.outerQueries,
       )
       Object.defineProperty(q.SELECT.from, 'uniqueSubqueryAlias', { value: uniqueSubqueryAlias })
@@ -976,9 +976,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
      */
     function isManagedAssocInFlatMode(e) {
       return (
-        (model.meta.transformation === 'odata' || model.meta.unfolded?.some(u => u === 'assocs')) &&
-        e.isAssociation &&
-        e.keys
+        e.isAssociation && e.keys && (model.meta.transformation === 'odata' || model.meta.unfolded?.includes('structs'))
       )
     }
   }
@@ -992,7 +990,7 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
    */
   function getElementForRef(ref, def) {
     return ref.reduce((prev, res) => {
-      return prev?.elements?.[res] || prev?._target?.elements[res]
+      return (prev?.elements || prev?.foreignKeys)?.[res] || prev?._target?.elements[res] // PLEASE REVIEW: should we add the .foreignKey check here for the non-ucsn case?
     }, def)
   }
 
@@ -1032,21 +1030,21 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
     if (!column) return column
     if (column.val || column.func || column.SELECT) return [column]
 
-    const structsAreUnfoldedAlready = model.meta.unfolded?.some(u => u === 'structs')
+    const structsAreUnfoldedAlready = model.meta.unfolded?.includes('structs')
     let { baseName, columnAlias, tableAlias } = names
     const { exclude, replace } = excludeAndReplace || {}
     const { $refLinks, flatName, isJoinRelevant } = column
     let leafAssoc
     let element = $refLinks ? $refLinks[$refLinks.length - 1].definition : column
     if (isWildcard && element.type === 'cds.LargeBinary') return []
-    if (element.on && !element.keys) return [] // unmanaged doesn't make it into columns
+    if (element.on && !element.keys)
+      return [] // unmanaged doesn't make it into columns
     else if (element.virtual === true) return []
     else if (!isJoinRelevant && flatName) baseName = flatName
     else if (isJoinRelevant) {
       const leaf = column.$refLinks[column.$refLinks.length - 1]
       leafAssoc = [...column.$refLinks].reverse().find(link => link.definition.isAssociation)
       let elements
-      //> REVISIT: remove once UCSN is standard (no more .foreignKeys)
       elements = leafAssoc.definition.elements || leafAssoc.definition.foreignKeys
       if (elements && leaf.alias in elements) {
         element = leafAssoc.definition
@@ -1278,7 +1276,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           }
         } else {
           const { list } = token
-          if (list.every(e => e.val)) // no need for transformation
+          if (list.every(e => e.val))
+            // no need for transformation
             transformedTokenStream.push({ list })
           else transformedTokenStream.push({ list: getTransformedTokenStream(list, $baseLink) })
         }
@@ -1776,13 +1775,13 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
             // naive assumption: if first step is the association itself, all following ref steps must be resolvable
             // within target `assoc.assoc.fk` -> `assoc.assoc_fk`
             else if (
-              lhs.$refLinks[0].definition ===
+              lhs.$refLinks[0]?.definition ===
               getParentEntity(assocRefLink.definition).elements[assocRefLink.definition.name]
             )
               result[i].ref = [assocRefLink.alias, lhs.ref.slice(1).join('_')]
             // naive assumption: if the path starts with an association which is not the association from
             // which the on-condition originates, it must be a foreign key and hence resolvable in the source
-            else if (lhs.$refLinks[0].definition.target) result[i].ref = [result[i].ref.join('_')]
+            else if (lhs.$refLinks[0]?.definition.target) result[i].ref = [result[i].ref.join('_')]
           }
         }
         if (backlink) {
@@ -1815,8 +1814,12 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
           result.splice(i, 3, ...(wrapInXpr ? [asXpr(backlinkOnCondition)] : backlinkOnCondition))
           i += wrapInXpr ? 1 : backlinkOnCondition.length // skip inserted tokens
         } else if (lhs.ref) {
-          if (lhs.ref[0] === '$self') result[i].ref.splice(0, 1, targetSideRefLink.alias)
-          else if (lhs.ref.length > 1) {
+          if (lhs.ref[0] === '$self') { // $self in ref of length > 1
+            // if $self is followed by association, the alias of the association must be used
+            if (lhs.$refLinks[1].definition.isAssociation) result[i].ref.splice(0, 1)
+            // otherwise $self is replaced by the alias of the entity
+            else result[i].ref.splice(0, 1, targetSideRefLink.alias)
+          } else if (lhs.ref.length > 1) {
             if (
               !(lhs.ref[0] in pseudos.elements) &&
               lhs.ref[0] !== assocRefLink.alias &&
@@ -1828,9 +1831,8 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
                 // first step is the association itself -> use it's name as it becomes the table alias
                 result[i].ref.splice(0, 1, assocRefLink.alias)
               } else if (
-                Object.values(
-                  targetSideRefLink.definition.elements || targetSideRefLink.definition._target.elements,
-                ).some(e => e === definition)
+                definition.name in
+                (targetSideRefLink.definition.elements || targetSideRefLink.definition._target.elements)
               ) {
                 // first step is association which refers to its foreign key by dot notation
                 result[i].ref = [targetSideRefLink.alias, lhs.ref.join('_')]

package/lib/fill-in-keys.js

@@ -4,78 +4,70 @@ const cds = require('@sap/cds')
 const propagateForeignKeys = require('@sap/cds/libx/_runtime/common/utils/propagateForeignKeys')
 const { enrichDataWithKeysFromWhere } = require('@sap/cds/libx/_runtime/common/utils/keys')
 
-const generateUUIDandPropagateKeys = (target, data, event) => {
-  if (!data) return
-  const keys = target.keys
-  for (const key in keys) {
-    const keyElement = keys[key]
-    if (
-      keyElement.type === 'cds.UUID' &&
-      !data[key] && event === 'CREATE' && 
-      !keyElement.parent.elements[keyElement._foreignKey4]?._isAssociationStrict
-    ) {
-      data[key] = cds.utils.uuid()
+const assoc4 = (e) => e.own('$fk4', ()=> {
+  const old = e['@odata.foreignKey4']; if (old) return old
+  if (!e.parent || !e.name || !e.name.includes('_')) return
+  if (e.name === 'ID_texts') return
+  if (e.name === 'DraftAdministrativeData_DraftUUID') return 'DraftAdministrativeData'
+  if (e.name.startsWith('up__')) return 'up_' // assumes up_ is a reserved name
+  const {elements} = e.parent, path = e.name.split('_')
+  for (let [p]=path, a, i=1; i < path.length; p += '_'+path[i++]) {
+    if ((a = elements[p])) {
+      if (a.keys) {
+        const tail = path.slice(i)
+        if (a.keys.some (k => k.ref.every((r,i) => r === tail[i]))) {
+          // process.stdout.write('> resolved assoc: ' + a.name + ' for: ' + this.name + '\n')
+          return a.name
+        }
+      }
+      return // not an assoc, or not the one we're looking for
     }
   }
-  const elements = target.elements
-  for (const element in elements) {
-    // if assoc keys are structured, do not ignore them, as they need to be flattened in propagateForeignKeys
-    if (
-      elements[element].key &&
-      !(elements[element]._isAssociationStrict && elements[element].is2one && element in data)
-    ) {
-      continue
-    }
+})
 
-    if (elements[element].is2one || elements[element].is2many) {
-      // propagate own foreign keys to propagate further to sub data
-      propagateForeignKeys(element, data, elements[element]._foreignKeys, elements[element].isComposition, {
-        deleteAssocs: true,
-      })
+const fkeys4 = (e) => {
+  let fkeys = e._foreignKeys
+  return typeof fkeys === 'function' ? fkeys.call(e) : fkeys
+}
 
-      let subData = data[element]
-      if (subData) {
-        if (!Array.isArray(subData)) {
-          subData = [subData]
-        }
-        for (const sub of subData) {
-          // For subData the event is set to 'CREATE' as require UUID generation
-          generateUUIDandPropagateKeys(elements[element]._target, sub, 'CREATE')
-        }
-      }
+const generateUUIDandPropagateKeys = (entity, data, event) => {
+  if (event === 'CREATE') {
+    const keys = entity.keys
+    for (const k in keys)
+      if (keys[k].isUUID && !data[k] && !assoc4(keys[k])) //> skip key assocs, and foreign keys thereof
+        data[k] = cds.utils.uuid()
+  }
+  for (const each in entity.elements) {
+    const e = entity.elements[each]
+    // if assoc keys are structured, do not ignore them, as they need to be flattened in propagateForeignKeys
+    if (!e.isAssociation || e.key && (e.isComposition || e.is2many || !(each in data))) continue
+    // propagate own foreign keys to propagate further to sub data
+    propagateForeignKeys (each, data, fkeys4(e), e.isComposition, { deleteAssocs: true, })
+
+    let subData = data[each]; if (!subData) continue
+    if (!Array.isArray(subData)) subData = [subData]
+    for (const sub of subData) {
+      // For subData the event is set to 'CREATE' as require UUID generation
+      generateUUIDandPropagateKeys (e._target, sub, 'CREATE')
     }
   }
 }
 
-/**
- * @callback nextCallback
- * @param {Error|undefined} error
- * @returns {Promise<unknown>}
- */
 
-/**
- * @param {import('@sap/cds/apis/services').Request} req
- * @param {nextCallback} next
- */
 module.exports = async function fill_in_keys(req, next) {
   // REVISIT dummy handler until we have input processing
   if (!req.target || !this.model || req.target._unresolved) return next()
-
   if (req.event === 'UPDATE') {
     // REVISIT for deep update we need to inject the keys first
-    enrichDataWithKeysFromWhere(req.data, req, this)
+    enrichDataWithKeysFromWhere (req.data, req, this)
   }
 
   // REVISIT no input processing for INPUT with rows/values
   if (!(req.query.INSERT?.rows || req.query.INSERT?.values)) {
-    if (Array.isArray(req.data)) {
-      for (const d of req.data) {
-        generateUUIDandPropagateKeys(req.target, d, req.event)
-      }
-    } else {
-      generateUUIDandPropagateKeys(req.target, req.data, req.event)
+    let {data} = req; if (!Array.isArray(data)) data = [data]
+    for (const d of data) {
+      generateUUIDandPropagateKeys (req.target, d, req.event)
     }
   }
-
   return next()
 }

package/lib/infer/index.js

@@ -22,7 +22,7 @@ for (const each in cdsTypes) cdsTypes[`cds.${each}`] = cdsTypes[each]
  * @param {import('@sap/cds/apis/csn').CSN} [model]
  * @returns {import('./cqn').Query} = q with .target and .elements
  */
-function infer(originalQuery, model = cds.context?.model || cds.model) {
+function infer(originalQuery, model) {
   if (!model) throw new Error('Please specify a model')
   const inferred = typeof originalQuery === 'string' ? cds.parse.cql(originalQuery) : cds.ql.clone(originalQuery)
 
@@ -114,6 +114,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
         (ref.length === 1 ? first.match(/[^.]+$/)[0] : ref[ref.length - 1].id || ref[ref.length - 1])
       if (alias in querySources) throw new Error(`Duplicate alias "${alias}"`)
       querySources[alias] = target
+      const last = from.$refLinks.at(-1)
+      last.alias = alias
     } else if (from.args) {
       from.args.forEach(a => inferTarget(a, querySources))
     } else if (from.SELECT) {
@@ -543,8 +545,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
           const target = definition._target || column.$refLinks[i - 1].target
           if (element) {
-            if($baseLink)
-              rejectNonFkAccess(element)
+            if ($baseLink) rejectNonFkAccess(element)
             const $refLink = { definition: elements[id], target }
             column.$refLinks.push($refLink)
           } else if (firstStepIsSelf) {
@@ -660,9 +661,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             // no unmanaged assoc in infix filter path
             if (!inExists && assoc.on)
               throw new Error(
-                `"${assoc.name}" in path "${column.ref
-                  .map(idOnly)
-                  .join('.')}" must not be an unmanaged association`
+                `"${assoc.name}" in path "${column.ref.map(idOnly).join('.')}" must not be an unmanaged association`,
               )
             // no non-fk traversal in infix filter in non-exists path
             if (nextStep && !assoc.on && !isForeignKeyOf(nextStep, assoc))
@@ -729,7 +728,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
               // if overwritten/excluded omit from wildcard elements
               // in elements the names are already flat so consider the prefix
               // in excluding, the elements are addressed without the prefix
-              if (!(name in elements || col.excluding?.some(e => e === k))) wildCardElements[name] = v
+              if (!(name in elements || col.excluding?.includes(k))) wildCardElements[name] = v
             })
             elements = { ...elements, ...wildCardElements }
           } else {
@@ -896,7 +895,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
               })
               mergePathIfNecessary(subPath, step)
             } else if (step.args || step.xpr) {
-              const nestedProp  = step.xpr ? 'xpr' : 'args'
+              const nestedProp = step.xpr ? 'xpr' : 'args'
               step[nestedProp].forEach(a => {
                 mergePathsIntoJoinTree(a, subPath)
               })
@@ -1134,15 +1133,10 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
  * Returns true if e is a foreign key of assoc.
  * this function is also compatible with unfolded csn (UCSN),
  * where association do not have foreign keys anymore.
- *
- * @param {*} e 
- * @param {*} assoc
- * @returns 
  */
 function isForeignKeyOf(e, assoc) {
-  if(!assoc.isAssociation) return false
-  if(assoc.foreignKeys) return e in assoc.foreignKeys
-  return assoc.elements && e in assoc.elements
+  if (!assoc.isAssociation) return false
+  return e in (assoc.elements || assoc.foreignKeys)
 }
 const idOnly = ref => ref.id || ref
 

package/lib/search.js

@@ -28,7 +28,6 @@ const getColumns = (
   entity,
   { onlyNames = false, removeIgnore = false, filterDraft = true, filterVirtual = false, keysOnly = false },
 ) => {
-  const skipDraft = filterDraft && entity._isDraftEnabled
   const columns = []
   const elements = entity.elements
 
@@ -37,7 +36,7 @@ const getColumns = (
     if (element.isAssociation) continue
     if (filterVirtual && element.virtual) continue
     if (removeIgnore && element['@cds.api.ignore']) continue
-    if (skipDraft && each in DRAFT_COLUMNS_UNION) continue
+    if (filterDraft && each in DRAFT_COLUMNS_UNION) continue
     if (keysOnly && !element.key) continue
     columns.push(onlyNames ? each : element)
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cap-js/db-service",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {