@cap-js/db-service 1.3.2 → 1.4.0

package/CHANGELOG.md

@@ -4,6 +4,24 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [1.4.0](https://github.com/cap-js/cds-dbs/compare/db-service-v1.3.2...db-service-v1.4.0) (2023-11-20)
+
+
+### Added
+
+* **`UPDATE`/`DELETE`:** Enable path expressions for improved data manipulation ([#325](https://github.com/cap-js/cds-dbs/issues/325)) ([94f0776](https://github.com/cap-js/cds-dbs/commit/94f077661cffad8f137dc692a2cb9b0ae5e4d75b))
+* **temporal data:** add time slice key to conflict clause ([#249](https://github.com/cap-js/cds-dbs/issues/249)) ([67b8edf](https://github.com/cap-js/cds-dbs/commit/67b8edf9b7f6b0fbab0010d7c93ed03a01e103ed))
+* use place holders for update and delete ([#323](https://github.com/cap-js/cds-dbs/issues/323)) ([81472b9](https://github.com/cap-js/cds-dbs/commit/81472b971183f701e401247611310be56745a87a))
+
+
+### Fixed
+
+* align time function behavior ([#322](https://github.com/cap-js/cds-dbs/issues/322)) ([c3ab40a](https://github.com/cap-js/cds-dbs/commit/c3ab40a007c105465349dd2f612178367b8e713a))
+* **calculated elements:** path expressions in `func.args` within `xpr` ([#321](https://github.com/cap-js/cds-dbs/issues/321)) ([cee25e3](https://github.com/cap-js/cds-dbs/commit/cee25e33cf289592a87779cfa34dddc53e467676))
+* Disconnect db service on shutdown ([#327](https://github.com/cap-js/cds-dbs/issues/327)) ([8471bda](https://github.com/cap-js/cds-dbs/commit/8471bda44fc030205abec45b1581b2cf6ed7c800))
+* non-fk access in filter conditions are properly rejected ([#336](https://github.com/cap-js/cds-dbs/issues/336)) ([4c948fe](https://github.com/cap-js/cds-dbs/commit/4c948fecead1de562e1583886516413e131a39aa))
+* **search:** check calculated columns at any depth ([#310](https://github.com/cap-js/cds-dbs/issues/310)) ([8fd6153](https://github.com/cap-js/cds-dbs/commit/8fd6153dfcd472a6d95c33faa58c4b3f96f485df))
+
 ## [1.3.2](https://github.com/cap-js/cds-dbs/compare/db-service-v1.3.1...db-service-v1.3.2) (2023-10-13)
 
 

package/lib/common/DatabaseService.js

@@ -6,10 +6,16 @@ const cds = require('@sap/cds/lib')
 /** @typedef {unknown} DatabaseDriver */
 
 class DatabaseService extends cds.Service {
+
+  init() {
+    cds.on('shutdown', () => this.disconnect())
+    return super.init()
+  }
+
   /**
    * Dictionary of connection pools per tenant
    */
-  pools = { _factory: this.factory }
+  pools = Object.setPrototypeOf({}, { _factory: this.factory })
 
   /**
    * Return a pool factory + options property as expected by
@@ -44,7 +50,9 @@ class DatabaseService extends cds.Service {
   async begin() {
     // We expect tx.begin() being called for an txed db service
     const ctx = this.context
-    if (!ctx) return this.tx().begin() // REVISIT: Is this correct? When does this happen?
+
+    // If .begin is called explicitly it starts a new transaction and executes begin
+    if (!ctx) return this.tx().begin()
 
     // REVISIT: tenant should be undefined if !this.isMultitenant
     let isMultitenant = 'multiTenant' in this.options ? this.options.multiTenant : cds.env.requires.multitenancy
@@ -111,11 +119,18 @@ class DatabaseService extends cds.Service {
    * @param {string} tenant
    */
   async disconnect(tenant) {
-    const pool = this.pools[tenant]
-    if (!pool) return
-    await pool.drain()
-    await pool.clear()
-    delete this.pools[tenant]
+    const _disconnect = async tenant => {
+      const pool = this.pools[tenant]
+      if (!pool) {
+        return
+      }
+      await pool.drain()
+      await pool.clear()
+      delete this.pools[tenant]
+    }
+    if (tenant == null)
+      return Promise.all(Object.keys(this.pools).map(_disconnect))
+    return _disconnect(tenant)
   }
 
   /**

package/lib/cql-functions.js

@@ -149,37 +149,37 @@ const StandardFunctions = {
    * Generates SQL statement that produces the year of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   year: x => `cast( strftime('%Y',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the month of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   month: x => `cast( strftime('%m',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the day of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   day: x => `cast( strftime('%d',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the hours of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   hour: x => `cast( strftime('%H',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the minutes of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   minute: x => `cast( strftime('%M',${x}) as Integer )`,
   /**
    * Generates SQL statement that produces the seconds of a given timestamp
    * @param {string} x
    * @returns {string}
-   */
+   * /
   second: x => `cast( strftime('%S',${x}) as Integer )`,
 
   /**

package/lib/cqn2sql.js

@@ -70,7 +70,7 @@ class CQN2SQLRenderer {
     /** @type {unknown[]} */
     this.values = [] // prepare values, filled in by subroutines
     this[cmd]((this.cqn = q)) // actual sql rendering happens here
-    if (vars?.length && !this.values.length) this.values = vars
+    if (vars?.length && !this.values?.length) this.values = vars
     const sanitize_values = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
     DEBUG?.(
       this.sql,
@@ -527,6 +527,9 @@ class CQN2SQLRenderer {
       .filter(c => !keys.includes(c))
       .map(c => `${this.quote(c)} = excluded.${this.quote(c)}`)
 
+    // temporal data
+    keys.push(...Object.values(q.target.elements).filter(e => e['@cds.valid.from']).map(e => e.name))
+
     keys = keys.map(k => this.quote(k))
     const conflict = updateColumns.length
       ? `ON CONFLICT(${keys}) DO UPDATE SET ` + updateColumns
@@ -872,7 +875,6 @@ class CQN2SQLRenderer {
 
       let val = _managed[element[annotation]?.['=']]
       if (val) sql = `coalesce(${sql}, ${this.func({ func: 'session_context', args: [{ val }] })})`
-
       else if (!isUpdate && element.default) {
         const d = element.default
         if (d.val !== undefined || d.ref?.[0] === '$now') {

package/lib/cqn4sql.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const cds = require('@sap/cds/lib')
-const { computeColumnsToBeSearched } = require('@sap/cds/libx/_runtime/cds-services/services/utils/columns.js')
+const { computeColumnsToBeSearched } = require('./search')
 
 const infer = require('./infer')
 
@@ -96,7 +96,46 @@ function cqn4sql(originalQuery, model = cds.context?.model || cds.model) {
       }
 
       if (queryNeedsJoins) {
-        transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
+        if (inferred.UPDATE || inferred.DELETE) {
+          const prop = inferred.UPDATE ? 'UPDATE' : 'DELETE'
+          const subquery = {
+            SELECT: {
+              from: { ...transformedFrom },
+              columns: [], // primary keys of the query target will be added later
+              where: [...transformedProp.where],
+            },
+          }
+          // The alias of the original query is now the alias for the subquery
+          // so that potential references in the where clause to the alias match.
+          // Hence, replace the alias of the original query with the next
+          // available alias, so that each alias is unique.
+          const uniqueSubqueryAlias = getNextAvailableTableAlias(transformedFrom.as)
+          transformedFrom.as = uniqueSubqueryAlias
+
+          // calculate the primary keys of the target entity, there is always exactly
+          // one query source for UPDATE / DELETE
+          const queryTarget = Object.values(originalQuery.sources)[0]
+          const keys = Object.values(queryTarget.elements).filter(e => e.key === true)
+          const primaryKey = { list: [] }
+          keys.forEach(k => {
+            // cqn4sql will add the table alias to the column later, no need to add it here
+            subquery.SELECT.columns.push({ ref: [k.name] })
+
+            // add the alias of the main query to the list of primary key references
+            primaryKey.list.push({ ref: [transformedFrom.as, k.name] })
+          })
+
+          const transformedSubquery = cqn4sql(subquery)
+
+          // replace where condition of original query with the transformed subquery
+          // correlate UPDATE / DELETE query with subquery by primary key matches
+          transformedQuery[prop].where = [primaryKey, 'in', transformedSubquery]
+
+          if (prop === 'UPDATE') transformedQuery.UPDATE.entity = transformedFrom
+          else transformedQuery.DELETE.from = transformedFrom
+        } else {
+          transformedQuery[kind].from = translateAssocsToJoins(transformedQuery[kind].from)
+        }
       }
     }
   }

package/lib/infer/index.js

@@ -499,20 +499,7 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             const elements = definition.elements || definition._target?.elements
             if (elements && id in elements) {
               const element = elements[id]
-              if (!inNestedProjection && !inCalcElement && element.target) {
-                // only fk access in infix filter
-                const nextStep = column.ref[1]?.id || column.ref[1]
-                // no unmanaged assoc in infix filter path
-                if (!inExists && element.on)
-                  throw new Error(
-                    `"${element.name}" in path "${column.ref
-                      .map(idOnly)
-                      .join('.')}" must not be an unmanaged association`,
-                  )
-                // no non-fk traversal in infix filter
-                if (nextStep && element.foreignKeys && !(nextStep in element.foreignKeys))
-                  throw new Error(`Only foreign keys of "${element.name}" can be accessed in infix filter`)
-              }
+              rejectNonFkAccess(element)
               const resolvableIn = definition.target ? definition._target : target
               column.$refLinks.push({ definition: elements[id], target: resolvableIn })
             } else {
@@ -557,6 +544,8 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
 
           const target = definition._target || column.$refLinks[i - 1].target
           if (element) {
+            if($baseLink)
+              rejectNonFkAccess(element)
             const $refLink = { definition: elements[id], target }
             column.$refLinks.push($refLink)
           } else if (firstStepIsSelf) {
@@ -658,6 +647,29 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
             }
           }
         }
+
+        /**
+         * Check if the next step in the ref is foreign key of `element`
+         * if not, an error is thrown.
+         * 
+         * @param {CSN.Element} element if this is an association, the next step must be a foreign key of the element.
+         */
+        function rejectNonFkAccess(element) {
+          if (!inNestedProjection && !inCalcElement && element.target) {
+            // only fk access in infix filter
+            const nextStep = column.ref[i + 1]?.id || column.ref[i + 1]
+            // no unmanaged assoc in infix filter path
+            if (!inExists && element.on)
+              throw new Error(
+                `"${element.name}" in path "${column.ref
+                  .map(idOnly)
+                  .join('.')}" must not be an unmanaged association`
+              )
+            // no non-fk traversal in infix filter
+            if (nextStep && element.foreignKeys && !(nextStep in element.foreignKeys))
+              throw new Error(`Only foreign keys of "${element.name}" can be accessed in infix filter`)
+          }
+        }
       })
 
       // ignore whole expand if target of assoc along path has ”@cds.persistence.skip”
@@ -680,10 +692,6 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           ? { ref: [...baseColumn.ref, ...column.ref], $refLinks: [...baseColumn.$refLinks, ...column.$refLinks] }
           : column
         if (isColumnJoinRelevant(colWithBase)) {
-          if (originalQuery.UPDATE)
-            throw new Error(
-              'Path expressions for UPDATE statements are not supported. Use “where exists” with infix filters instead.',
-            )
           Object.defineProperty(column, 'isJoinRelevant', { value: true })
           joinTree.mergeColumn(colWithBase, originalQuery.outerQueries)
         }
@@ -873,20 +881,26 @@ function infer(originalQuery, model = cds.context?.model || cds.model) {
           if (leafOfCalculatedElementRef.value) mergePathsIntoJoinTree(leafOfCalculatedElementRef.value, basePath)
 
           mergePathIfNecessary(basePath, arg)
-        } else if (arg.xpr) {
-          arg.xpr.forEach(step => {
+        } else if (arg.xpr || arg.args) {
+          const prop = arg.xpr ? 'xpr' : 'args'
+          arg[prop].forEach(step => {
+            const subPath = { $refLinks: [...basePath.$refLinks], ref: [...basePath.ref] }
             if (step.ref) {
-              const subPath = { $refLinks: [...basePath.$refLinks], ref: [...basePath.ref] }
               step.$refLinks.forEach((link, i) => {
                 const { definition } = link
                 if (definition.value) {
-                  mergePathsIntoJoinTree(definition.value)
+                  mergePathsIntoJoinTree(definition.value, subPath)
                 } else {
                   subPath.$refLinks.push(link)
                   subPath.ref.push(step.ref[i])
                 }
               })
               mergePathIfNecessary(subPath, step)
+            } else if (step.args || step.xpr) {
+              const nestedProp  = step.xpr ? 'xpr' : 'args'
+              step[nestedProp].forEach(a => {
+                mergePathsIntoJoinTree(a, subPath)
+              })
             }
           })
         }

package/lib/search.js

@@ -0,0 +1,164 @@
+'use strict'
+
+const DRAFT_COLUMNS_UNION = {
+  IsActiveEntity: 1,
+  HasActiveEntity: 1,
+  HasDraftEntity: 1,
+  DraftAdministrativeData_DraftUUID: 1,
+  SiblingEntity: 1,
+  DraftAdministrativeData: 1,
+}
+const DEFAULT_SEARCHABLE_TYPE = 'cds.String'
+
+/**
+ * This method gets all columns for an entity.
+ * It includes the generated foreign keys from managed associations, structured elements and complex and custom types.
+ * As well, it provides the annotations starting with '@' for each column.
+ *
+ * @param {object} entity - the csn entity
+ * @param {object} [options]
+ * @param [options.onlyNames=false] - decides if the column name or the csn representation of the column should be returned
+ * @param [options.filterDraft=false] - indicates whether the draft columns should be filtered if the entity is draft enabled
+ * @param [options.removeIgnore=false]
+ * @param [options.filterVirtual=false]
+ * @param [options.keysOnly=false]
+ * @returns {Array<object>} - array of columns
+ */
+const getColumns = (
+  entity,
+  { onlyNames = false, removeIgnore = false, filterDraft = true, filterVirtual = false, keysOnly = false },
+) => {
+  const skipDraft = filterDraft && entity._isDraftEnabled
+  const columns = []
+  const elements = entity.elements
+
+  for (const each in elements) {
+    const element = elements[each]
+    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 (keysOnly && !element.key) continue
+    columns.push(onlyNames ? each : element)
+  }
+
+  return columns
+}
+
+const _isColumnCalculated = (query, columnName) => {
+  if (!query) return false
+  if (query.SELECT?.columns?.find(col => col.xpr && col.as === columnName)) return true
+  return _isColumnCalculated(query._target?.query, columnName)
+}
+
+const _getSearchableColumns = entity => {
+  const columnsOptions = { removeIgnore: true, filterVirtual: true }
+  const columns = getColumns(entity, columnsOptions)
+  const cdsSearchTerm = '@cds.search'
+  const cdsSearchKeys = []
+  const cdsSearchColumnMap = new Map()
+
+  for (const key in entity) {
+    if (key.startsWith(cdsSearchTerm)) cdsSearchKeys.push(key)
+  }
+
+  let atLeastOneColumnIsSearchable = false
+
+  // build a map of columns annotated with the @cds.search annotation
+  for (const key of cdsSearchKeys) {
+    const columnName = key.split(cdsSearchTerm + '.').pop()
+
+    // REVISIT: for now, exclude search using path expression, as deep search is not currently
+    // supported
+    if (columnName.includes('.')) {
+      continue
+    }
+
+    const annotationKey = `${cdsSearchTerm}.${columnName}`
+    const annotationValue = entity[annotationKey]
+    if (annotationValue) atLeastOneColumnIsSearchable = true
+    cdsSearchColumnMap.set(columnName, annotationValue)
+  }
+
+  const searchableColumns = columns.filter(column => {
+    const annotatedColumnValue = cdsSearchColumnMap.get(column.name)
+
+    // the element is searchable if it is annotated with the @cds.search, e.g.:
+    // `@cds.search { element1: true }` or `@cds.search { element1 }`
+    if (annotatedColumnValue) return true
+
+    // if at least one element is explicitly annotated as searchable, e.g.:
+    // `@cds.search { element1: true }` or `@cds.search { element1 }`
+    // and it is not the current column name, then it must be excluded from the search
+    if (atLeastOneColumnIsSearchable) return false
+
+    // the element is considered searchable if it is explicitly annotated as such or
+    // if it is not annotated and the column is typed as a string (excluding elements/elements expressions)
+    return (
+      annotatedColumnValue === undefined &&
+      column._type === DEFAULT_SEARCHABLE_TYPE &&
+      !_isColumnCalculated(entity?.query, column.name)
+    )
+  })
+
+  // if the @cds.search annotation is provided -->
+  // Early return to ignore the interpretation of the @Search.defaultSearchElement
+  // annotation when an entity is annotated with the @cds.search annotation.
+  // The @cds.search annotation overrules the @Search.defaultSearchElement annotation.
+  if (cdsSearchKeys.length > 0) {
+    return searchableColumns.map(column => column.name)
+  }
+
+  return searchableColumns.map(column => column.name)
+}
+
+/**
+ * @returns {Array<object>} - array of columns
+ */
+const computeColumnsToBeSearched = (cqn, entity = { __searchableColumns: [] }, alias) => {
+  let toBeSearched = []
+
+  // aggregations case
+  // in the new parser groupBy is moved to sub select.
+  if (cqn._aggregated || /* new parser */ cqn.SELECT.groupBy || cqn.SELECT?.from?.SELECT?.groupBy) {
+    cqn.SELECT.columns &&
+      cqn.SELECT.columns.forEach(column => {
+        if (column.func) {
+          // exclude $count by SELECT of number of Items in a Collection
+          if (
+            cqn.SELECT.columns.length === 1 &&
+            column.func === 'count' &&
+            (column.as === '_counted_' || column.as === '$count')
+          ) {
+            return
+          }
+
+          toBeSearched.push(column)
+          return
+        }
+
+        const columnRef = column.ref
+        if (columnRef) {
+          if (entity.elements[columnRef[columnRef.length - 1]]?._type !== DEFAULT_SEARCHABLE_TYPE) return
+          column = { ref: [...column.ref] }
+          if (alias) column.ref.unshift(alias)
+          toBeSearched.push(column)
+        }
+      })
+  } else {
+    toBeSearched = entity.own('__searchableColumns') || entity.set('__searchableColumns', _getSearchableColumns(entity))
+    if (cqn.SELECT.groupBy) toBeSearched = toBeSearched.filter(tbs => cqn.SELECT.groupBy.some(gb => gb.ref[0] === tbs))
+    toBeSearched = toBeSearched.map(c => {
+      const col = { ref: [c] }
+      if (alias) col.ref.unshift(alias)
+      return col
+    })
+  }
+
+  return toBeSearched
+}
+
+module.exports = {
+  getColumns,
+  computeColumnsToBeSearched,
+}

package/package.json

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