@cap-js/db-service 1.6.1 → 1.6.2

package/CHANGELOG.md

@@ -4,6 +4,18 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [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/cqn2sql.js

@@ -479,10 +479,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 += '}'
@@ -650,7 +651,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 +693,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]) })
         }
       }

package/lib/cqn4sql.js

@@ -976,9 +976,8 @@ 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 +991,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,7 +1031,7 @@ 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
@@ -1046,7 +1045,6 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       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
@@ -1828,9 +1826,7 @@ 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

@@ -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.2",
   "description": "CDS base database service",
   "homepage": "https://github.com/cap-js/cds-dbs/tree/main/db-service#cds-base-database-service",
   "repository": {