@sap/cds 8.9.4 → 9.0.2

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

@@ -1,92 +0,0 @@
-const { getEntityFromCQN } = require('../../common/utils/entityFromCqn')
-
-const _getStructuredTypes = entity => {
-  return Object.values(entity.elements || {}).filter(e => e.elements || e.isAssociation)
-}
-
-const _handleNavigation = (structuredType, data, prefixes) => {
-  if (!data) return
-  const nestedStructuredTypes = _getStructuredTypes(structuredType._target)
-
-  for (const nestedStructuredType of nestedStructuredTypes) {
-    if (structuredType.is2many) {
-      for (const entry of data) {
-        _flatToStructured(nestedStructuredType, entry, [...prefixes])
-      }
-    } else {
-      _flatToStructured(nestedStructuredType, data, [...prefixes])
-    }
-  }
-}
-
-const _allValuesAreNull = data => {
-  const values = Object.values(data)
-  return values.length && !Object.values(data).some(d => d !== null)
-}
-
-// REVISIT: very limited, see xtests in structured-x4
-const _flatToStructured = (structuredType, data, prefixes = [], subData = data) => {
-  if (structuredType.isAssociation) {
-    // expanded navigation
-    _handleNavigation(structuredType, data[structuredType.name], prefixes)
-    return
-  }
-
-  if (structuredType.elements) {
-    subData[structuredType.name] = subData[structuredType.name] || {}
-    prefixes.push(structuredType.name)
-  }
-
-  for (const element in structuredType.elements) {
-    if (structuredType.elements[element].elements) {
-      _flatToStructured(structuredType.elements[element], data, [...prefixes], subData[structuredType.name])
-      continue
-    }
-
-    // expand of navigation in a structured combined with requesting structured elements
-    if (subData[structuredType.name] !== undefined && structuredType.elements[element].isAssociation) {
-      _handleNavigation(structuredType.elements[element], subData[structuredType.name][element], [])
-      continue
-    }
-
-    const propertyValue = data[`${prefixes.join('_')}_${element}`]
-    if (propertyValue !== undefined) {
-      subData[structuredType.name][element] = data[`${prefixes.join('_')}_${element}`] // data[property]
-      delete data[`${prefixes.join('_')}_${element}`]
-    }
-  }
-
-  if (_allValuesAreNull(subData[structuredType.name])) {
-    subData[structuredType.name] = null
-  }
-
-  if (subData[structuredType.name] && Object.keys(subData[structuredType.name]).length === 0) {
-    delete subData[structuredType.name]
-  }
-}
-
-/**
- * Formats flat data to structured data
- *
- * @param result - the result of the event
- * @param req - the context object
- * @returns {Promise}
- */
-module.exports = function (result, req) {
-  // REVISIT if result has a property length that is 0 we will return here
-  if (!this.model || result == null || result.length === 0) return
-
-  // REVISIT: No entity for sets/unions outside of common draft scenarios
-  const entity = getEntityFromCQN(req, this)
-  if (!entity) return
-
-  if (!Array.isArray(result)) result = [result]
-  const structuredTypes = _getStructuredTypes(entity)
-  for (let i = 0; i < result.length; i++) {
-    const d = result[i]
-
-    for (const structuredType of structuredTypes) {
-      _flatToStructured(structuredType, d)
-    }
-  }
-}

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

@@ -1,97 +0,0 @@
-// REVISIT: UpdateResult
-// const UpdateResult = require('../result/UpdateResult')
-
-const onlyKeysRemain = require('../../common/utils/onlyKeysRemain')
-const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
-
-const allKeysAreProvided = req => {
-  const data = req.data && (Array.isArray(req.data) ? req.data : [req.data])
-  for (const key of Object.values(req.target.keys || {})) {
-    if (key._isAssociationStrict || key.name in DRAFT_COLUMNS_MAP) {
-      continue
-    }
-    for (const d of data) {
-      if (d[key.name] === undefined) return false
-    }
-  }
-  return true
-}
-
-const _enrichKeysFromOldData = (req, oldData) => {
-  const data = req.data && (Array.isArray(req.data) ? req.data : [req.data])
-  for (const key of Object.values(req.target.keys)) {
-    for (const d of data) {
-      // If key not in data, check if in old data (example case: PATCH singleton)
-      if (d[key.name] === undefined && oldData && oldData[key.name] !== undefined) {
-        d[key.name] = oldData[key.name]
-      }
-    }
-  }
-}
-
-const _addKeysToQuery = req => {
-  req.query.where(
-    Object.keys(req.data).reduce((prev, curr) => {
-      if (req.target.keys[curr]) {
-        prev[curr] = req.data[curr]
-      }
-      return prev
-    }, {})
-  )
-}
-
-const _targetKeys = target => {
-  return Object.values(target.keys || {})
-    .filter(k => !(k.is2one || k.is2many))
-    .map(k => ({ ref: [k.name] }))
-}
-
-/**
- * Generic Handler for UPDATE requests.
- * REVISIT: correct description?
- * In case of success it returns the updated entry.
- * If the entry to be updated does not exist, a new entry is created.
- *
- * @param req - cds.Request
- */
-module.exports = async function (req) {
-  if (typeof req.query === 'string') {
-    return this._execute.sql(this.dbc, req.query, req.data)
-  }
-
-  if (req.target && !req.target._unresolved && req.target._isSingleton) {
-    if (!allKeysAreProvided(req)) {
-      // REVISIT: There can also be renaming... we better use resolveView here.
-      const targetKeys = _targetKeys(req.target)
-      const readKeysCQN =
-        req.target.query && req.target.query.SELECT
-          ? {
-              SELECT: Object.assign({ columns: targetKeys, one: true }, req.target.query.SELECT)
-            }
-          : SELECT.from(req.target).columns(targetKeys)
-
-      // REVISIT: avoid additional read
-      const current = await this._read(this.model, this.dbc, readKeysCQN, req)
-      _enrichKeysFromOldData(req, current)
-    }
-
-    if (!req.query.UPDATE.where && req.target.keys) {
-      _addKeysToQuery(req)
-    }
-  }
-
-  if (onlyKeysRemain(req)) return
-
-  try {
-    const result = await this._update(this.model, this.dbc, req)
-    return result
-  } catch (err) {
-    // REVISIT: db specifics
-    if (err.message.match(/unique constraint/i)) {
-      err.originalMessage = err.message
-      err.message = 'UNIQUE_CONSTRAINT_VIOLATION'
-      err.code = 400
-    }
-    req.reject(err)
-  }
-}

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

@@ -1,83 +0,0 @@
-/*
- * handler for converting virtual fields to { val: null, as: 'myVirtualField' } by READ
- */
-
-const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
-const { getEntityNameFromCQN } = require('../../common/utils/entityFromCqn')
-
-const _getElement = (ref, target, alias) =>
-  alias
-    ? (ref[0] === alias && target.elements[ref[1]]) || target.elements[ref[0]]
-    : target.elements[ref[0]] || target.elements[ref[1]]
-
-const _convert = (columns, target, model, alias) => {
-  if (!target) return
-  for (const col of columns) {
-    if (!col.ref) continue
-    const element = _getElement(col.ref, target, alias)
-    if (element) {
-      if (element.virtual) {
-        col.as = col.as || col.ref[col.ref.length - 1]
-        col.cast = { type: element._type }
-        delete col.ref
-        col.val = (element.default && element.default.val) || null
-      }
-      if (col.expand && element.isAssociation) {
-        _convert(col.expand, model.definitions[element.target], model)
-      }
-    }
-  }
-}
-
-const _convert4ref = (query, model) => {
-  const { entityName, alias } = getEntityNameFromCQN(query)
-  const columns = query.SELECT.columns || []
-  const target = entityName && model.definitions[ensureNoDraftsSuffix(entityName)]
-  if (target) _convert(columns, target, model, alias)
-}
-
-const _convert4union = (SELECT, model) => {
-  for (const arg of SELECT.from.SET.args) {
-    const { entityName, alias } = getEntityNameFromCQN(arg)
-    const target = entityName && model.definitions[ensureNoDraftsSuffix(entityName)]
-    if (target) {
-      const columns = (arg.SELECT && arg.SELECT.columns) || []
-      _convert(columns, target, model, alias)
-    }
-  }
-}
-
-const _convert4join = (SELECT, model) => {
-  const columns = SELECT.columns || []
-  for (const arg of SELECT.from.args) {
-    const { entityName, alias } = getEntityNameFromCQN(arg)
-    const target = entityName && model.definitions[ensureNoDraftsSuffix(entityName)]
-    if (target) {
-      _convert(columns, target, model, alias)
-    }
-  }
-}
-
-// REVISIT: Refactor to have a generic 'columns processor'
-const _convertViruals = (query, model) => {
-  if (!query.SELECT.from) return
-  if (query.SELECT.from.SET) return _convert4union(query.SELECT, model)
-  if (query.SELECT.from.args) return _convert4join(query.SELECT, model)
-  if (query.SELECT.from.SELECT) {
-    _convert4ref(query, model)
-    return _convertViruals(query.SELECT.from, model)
-  }
-  return _convert4ref(query, model)
-}
-
-const convertVirtuals = function (req, _model) {
-  const model = this.model || _model
-  if (!model) return
-  if (req.query.SELECT) _convertViruals(req.query, model)
-}
-
-convertVirtuals._initial = true
-
-module.exports = {
-  convertVirtuals
-}

package/libx/_runtime/db/query/delete.js

@@ -1,39 +0,0 @@
-const { getFlatArray, processCQNs } = require('../utils/deep')
-const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
-const { hasDeepDelete, getDeepDeleteCQNs, getSetNullParentForeignKeyCQNs } = require('../../common/composition')
-
-const deleteFn = (executeDeleteCQN, executeUpdateCQN) => async (model, dbc, query, req) => {
-  const { user, locale, timestamp } = req
-  const isoTs = normalizeTimestamp(timestamp)
-
-  let result
-  if (model && hasDeepDelete(model, query)) {
-    let cqns = await getDeepDeleteCQNs(model, req)
-
-    // the delete chunks, i.e., how many deletes can be processed in parallel
-    const chunks = []
-    for (const each of cqns) {
-      if (each.length) chunks.push(each.length)
-    }
-
-    cqns = getFlatArray(cqns)
-
-    if (cqns.length === 0) return 0
-
-    const results = await processCQNs(executeDeleteCQN, cqns, model, dbc, user, locale, isoTs, chunks)
-    // return number of affected rows of "root cqn"
-    result = results[results.length - 1]
-  } else {
-    result = await executeDeleteCQN(model, dbc, query, user, locale, isoTs)
-    if (result && model) {
-      const updateCQNs = await getSetNullParentForeignKeyCQNs(model, req)
-      for (const cqn of updateCQNs) {
-        await executeUpdateCQN(model, dbc, cqn, user, locale, isoTs)
-      }
-    }
-  }
-
-  return result
-}
-
-module.exports = deleteFn

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

@@ -1,13 +0,0 @@
-const run = require('./run')
-const insert = require('./insert')
-const read = require('./read')
-const update = require('./update')
-const deleet = require('./delete')
-
-module.exports = {
-  run,
-  insert,
-  read,
-  update,
-  delete: deleet
-}

package/libx/_runtime/db/query/insert.js

@@ -1,21 +0,0 @@
-const { hasDeepInsert, getDeepInsertCQNs } = require('../../common/composition')
-const { getFlatArray, processCQNs } = require('../utils/deep')
-const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
-
-const insert = executeInsertCQN => async (model, dbc, query, req) => {
-  const { user, locale, timestamp } = req
-  const isoTs = normalizeTimestamp(timestamp)
-
-  if (model && hasDeepInsert(model, query)) {
-    const cqns = getFlatArray(getDeepInsertCQNs(model, query))
-
-    // return array of individual results
-    if (cqns.length === 0) return []
-    const results = await processCQNs(executeInsertCQN, cqns, model, dbc, user, locale, isoTs)
-    return getFlatArray(results)
-  }
-
-  return executeInsertCQN(model, dbc, query, user, locale, isoTs)
-}
-
-module.exports = insert

package/libx/_runtime/db/query/read.js

@@ -1,97 +0,0 @@
-const cds = require('../../cds')
-const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
-const { deepCopy } = require('../../common/utils/copy')
-const getError = require('../../common/error')
-
-function _arrayWithCount(a, count) {
-  const _map = a.map
-  const map = (..._) => _arrayWithCount(_map.call(a, ..._), count)
-  return Object.defineProperties(a, {
-    $count: { value: count, enumerable: false, configurable: true, writable: true },
-    map: { value: map, enumerable: false, configurable: true, writable: true }
-  })
-}
-
-function _createCountQuery(query) {
-  // REVISIT: Use query.clone() instead
-  let _query = { SELECT: deepCopy(query.SELECT) }
-  delete _query.SELECT.orderBy // not necessary to keep that
-  delete _query.SELECT.limit
-  // Also change columns in sub queries
-  if (_query.SELECT.from.SET) {
-    _query.SELECT.from.SET.args.forEach(subCountQuery => {
-      subCountQuery.SELECT.columns = [{ val: 1 }]
-    })
-  }
-  if (query.SELECT.__countAggregated) {
-    _query = SELECT.from(_query)
-  }
-  _query.SELECT.columns = [{ func: 'count', args: [{ val: 1 }], as: '$count' }]
-  if (query.SELECT._4odata) _query.SELECT._4odata = true
-  return _query
-}
-
-const countValue = countResults => {
-  if (!countResults.length) return 0
-  const countResult = countResults[0]
-  if (countResult._counted_ != null) return countResult._counted_
-  if (countResult.$count != null) return countResult.$count
-}
-
-const read = (executeSelectCQN, executeStreamCQN, convertStreams) => (model, dbc, query, req) => {
-  const { user, locale, timestamp } = req
-  const isoTs = normalizeTimestamp(timestamp)
-
-  if (cds.env.features.stream_compat && query._streaming) {
-    if (!query.SELECT || !query.SELECT.columns) {
-      throw getError(500, 'Invalid SELECT statement for streaming')
-    }
-
-    return executeStreamCQN({ model, dbc, query, user, locale, isoTs })
-  }
-
-  // REVISIT: streaming from OData - to be generalized to all streaming properties
-  if (query.SELECT?.columns?.find(col => col.as === '$mediaContentType')) {
-    return executeStreamCQN({ model, dbc, query, user, locale, isoTs })
-  }
-
-  // needed in case of expand
-  if (query._target !== req.target) query._target = req.target
-
-  if (query.SELECT.count) {
-    if (query.SELECT.limit) {
-      // IMPORTANT: do not change order!
-      // 1. create the count query synchronously, because it works on a copy
-      // 2. run the result query, duplicate names ( SELECT ID, ID ...) throw an error synchronously
-      // 3. run the count query
-      // reason is that executeSelectCQN modifies the query
-      const countQuery = _createCountQuery(query)
-      const resultPromise =
-        query.SELECT.limit?.rows?.val === 0
-          ? Promise.resolve([])
-          : executeSelectCQN(model, dbc, query, user, locale, isoTs)
-      const countPromise = executeSelectCQN(model, dbc, countQuery, user, locale, isoTs)
-
-      // use allSettled here, so all executions are awaited before we rollback
-      return Promise.allSettled([countPromise, resultPromise]).then(results => {
-        const rejection = results.find(p => p.status === 'rejected')
-        if (rejection) throw rejection.reason
-
-        const [{ value: countResult }, { value: result }] = results
-        return _arrayWithCount(result, countValue(countResult))
-      })
-    }
-
-    return executeSelectCQN(model, dbc, query, user, locale, isoTs).then(result =>
-      _arrayWithCount(result, result.length)
-    )
-  }
-
-  return executeSelectCQN(model, dbc, query, user, locale, isoTs).then(result => {
-    if (!cds.env.features.stream_compat) convertStreams(query.SELECT.columns, query.target, result, query.SELECT.one)
-
-    return result
-  })
-}
-
-module.exports = read

package/libx/_runtime/db/query/run.js

@@ -1,30 +0,0 @@
-const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
-
-const run = (insert, read, update, deleet, cqn, sql) => (model, dbc, query, req, values) => {
-  if (typeof query === 'string') {
-    return sql(dbc, query, values)
-  }
-
-  if (query.SELECT) {
-    return read(model, dbc, query, req)
-  }
-
-  if (query.DELETE) {
-    return deleet(model, dbc, query, req)
-  }
-
-  if (query.INSERT) {
-    return insert(model, dbc, query, req)
-  }
-
-  if (query.UPDATE) {
-    return update(model, dbc, query, req)
-  }
-
-  const { user, locale, timestamp } = req
-  const isoTs = normalizeTimestamp(timestamp)
-
-  return cqn(model, dbc, query, user, locale, isoTs)
-}
-
-module.exports = run

package/libx/_runtime/db/query/update.js

@@ -1,94 +0,0 @@
-const cds = require('../../cds')
-const preservedSymbol = Symbol('preserved')
-const { hasDeepUpdate, getDeepUpdateCQNs, selectDeepUpdateData } = require('../../common/composition')
-const { getFlatArray, processCQNs } = require('../utils/deep')
-const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
-const onlyKeysRemain = require('../../common/utils/onlyKeysRemain')
-
-const isMoreThanManaged = (cqn, entity) => {
-  return (
-    cqn[preservedSymbol] ||
-    Object.keys(cqn.UPDATE.data).some(
-      key =>
-        !(key in entity.keys) &&
-        (entity.elements[key]['@cds.on.update'] === undefined || !cqn.UPDATE.data[key]?.startsWith('$'))
-    )
-  )
-}
-
-const isManaged = (cqn, entity) => {
-  return Object.keys(cqn.UPDATE.data).some(
-    key => entity.elements[key]['@cds.on.update'] && cqn.UPDATE.data[key] !== undefined
-  )
-}
-
-const _getFilteredCqns = (cqns, model) => {
-  // right to left processing necessary!
-  for (let i = cqns.length - 1; i > 0; i--) {
-    const cqn = cqns[i]
-
-    const entity = model && cqn.UPDATE && model.definitions[cqn.UPDATE.entity]
-    if (!entity) {
-      Object.defineProperty(cqn, preservedSymbol, { value: true })
-      continue
-    }
-
-    // do not filter if there is a property that is not a key or managed by us (its value starts with $)
-    let moreThanManaged = isMoreThanManaged(cqn, entity)
-
-    if (moreThanManaged) {
-      Object.defineProperty(cqn, preservedSymbol, { value: true })
-      const parentEntity = cqn.parent?.UPDATE && model.definitions[cqn.parent.UPDATE.entity]
-      if (parentEntity && isManaged(cqn.parent, parentEntity)) {
-        Object.defineProperty(cqn.parent, preservedSymbol, { value: true })
-      }
-      continue
-    }
-  }
-
-  const rootCqn = cqns[0]
-  if (rootCqn) {
-    // no need to process first (= root)
-    Object.defineProperty(rootCqn, preservedSymbol, { value: true })
-  }
-
-  return cqns.filter(cqn => {
-    const entity = model && cqn.UPDATE && model.definitions[cqn.UPDATE.entity]
-    if (entity && onlyKeysRemain({ query: cqn, target: entity, data: cqn.UPDATE.data })) {
-      return false
-    }
-    return cqn[preservedSymbol]
-  })
-}
-
-const update = executeUpdateCQN => async (model, dbc, req) => {
-  const { query, user, locale, timestamp } = req
-  const isoTs = normalizeTimestamp(timestamp)
-
-  if (model && hasDeepUpdate(model, query)) {
-    // REVISIT: avoid additional read
-    const selectData = await selectDeepUpdateData(cds.db, model, req)
-    const cqns = await getDeepUpdateCQNs(model, req, selectData)
-
-    // the delete chunks, i.e., how many deletes can be processed in parallel
-    const chunks = []
-    for (const each of cqns) chunks.push(each.filter(e => e.DELETE).length)
-
-    // remove child queries that only want to update @cds.on.update properties
-    let _cqns = Array.from(cqns)
-    _cqns = getFlatArray(_cqns)
-    _cqns = _getFilteredCqns(_cqns, model)
-
-    if (_cqns.length === 0) return 0
-    const results = await processCQNs(executeUpdateCQN, _cqns, model, dbc, user, locale, isoTs, chunks)
-
-    // return number of affected rows of "root cqn", if an update, 1 otherwise (as not update of root but its children)
-    if (_cqns[0].UPDATE) return results[0]
-    return 1
-  }
-
-  // REVISIT: don't invoke setters if not needed
-  return executeUpdateCQN(model, dbc, query, user, locale, isoTs)
-}
-
-module.exports = update

package/libx/_runtime/db/result/InsertResult.js

@@ -1,87 +0,0 @@
-const iterator = Symbol.iterator
-
-module.exports = class InsertResult {
-  constructor(req, results) {
-    this.req = req
-    this.results = results
-  }
-
-  /*
-   * iterator for getting the keys
-   */
-  get [iterator]() {
-    if (this.req.query.INSERT.as) {
-      // dummy iterator with correct length
-      return (super[iterator] = function* () {
-        for (let i = 0; i < this.affectedRows; i++) yield {}
-      })
-    }
-
-    const { target } = this.req
-    if (!target || !target.keys) return (super[iterator] = this.results[iterator])
-    const { entries, columns, rows, values } = this.req.query.INSERT
-    const keys = Object.keys(target.keys)
-    const [k1] = keys
-
-    if (entries && k1 in entries[0]) {
-      return (super[iterator] = function* () {
-        for (const each of entries) {
-          const kees = {}
-          for (const k of keys) kees[k] = each[k]
-          yield kees
-        }
-      })
-    }
-
-    if (columns) {
-      const indices = {}
-      for (const k of keys) {
-        const i = columns.indexOf(k)
-        if (i >= 0) indices[k] = i
-      }
-
-      if (rows && k1 in indices) {
-        return (super[iterator] = function* () {
-          for (const each of rows) {
-            const kees = {}
-            for (const k of keys) kees[k] = each[indices[k]]
-            yield kees
-          }
-        })
-      }
-
-      if (values && k1 in indices) {
-        return (super[iterator] = function* () {
-          for (const each of [values]) {
-            const kees = {}
-            for (const k of keys) kees[k] = each[indices[k]]
-            yield kees
-          }
-        })
-      }
-    }
-
-    return (super[iterator] = function* () {
-      // REVISIT: sqlite only returns a single lastID per row -> how is that with others?
-      // only up to # of root entries
-      const roots = this.results.slice(0, this.affectedRows)
-      for (const each of roots) yield { [k1]: each.lastID || each }
-    })
-  }
-
-  /*
-   * the number of inserted (root) entries or the number of affectedRows in case of INSERT into SELECT
-   */
-  get affectedRows() {
-    if (this.req.query.INSERT.as) return (super.affectedRows = this.results[0].affectedRows)
-    const { entries, rows } = this.req.query.INSERT
-    return (super.length = (entries && entries.length) || (rows && rows.length) || this.results.length || 1)
-  }
-
-  /*
-   * for checks such as res > 2
-   */
-  valueOf() {
-    return this.affectedRows
-  }
-}