@sap/cds 8.9.4 → 9.0.2

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

@@ -1,13 +0,0 @@
-const { hasExpand, createJoinCQNFromExpanded } = require('./expandCQNToJoin')
-const rawToExpanded = require('./rawToExpanded')
-const expandV2 = require('./expand-v2')
-
-/*
- * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
- */
-module.exports = {
-  hasExpand,
-  createJoinCQNFromExpanded,
-  rawToExpanded,
-  expandV2
-}

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

@@ -1,250 +0,0 @@
-const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
-const DRAFT_COLUMNS_ARRAY = Object.keys(DRAFT_COLUMNS_MAP)
-
-const EXPAND = Symbol.for('sap.cds.expand')
-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 CLEANUP_KEYS = Symbol.for('sap.cds.cleanupKeys')
-
-class RawToExpanded {
-  constructor(configs, queries, one, rootEntity) {
-    this._one = one
-    this._toManyResults = { expand: {} }
-    this._result = []
-    this._configs = configs
-    this._queries = queries
-    this._rootEntity = rootEntity
-  }
-
-  /**
-   * Parses and converts the raw result set(s) into one single expanded result set.
-   *
-   * @returns {Promise<Array>}
-   */
-  async toExpanded() {
-    const { queries, mappings } = this._configs
-
-    const conversionMapper = new Map()
-    for (const each of queries) {
-      if (each._conversionMapper) for (const [k, v] of [...each._conversionMapper]) conversionMapper.set(k, v)
-    }
-
-    const queryResults = await Promise.all(this._queries)
-    // NOTE: this doesn't work:
-    // for (let each of this._queries) await each
-
-    for (let i = 0, length = queryResults.length; i < length; i++) {
-      const { _toManyTree: toManyTree = [] } = queries[i]
-      const result = queryResults[i]
-      if (toManyTree.length === 0) {
-        this._parseMainResult(result, mappings, conversionMapper, toManyTree)
-      } else {
-        this._parseExpandResult(result, mappings, conversionMapper, toManyTree)
-      }
-    }
-
-    return this._one ? this._result[0] || null : this._result
-  }
-
-  _parseMainResult(result, mappings, conversionMapper, toManyTree) {
-    for (const entry of result) {
-      const parsed = this._parseRaw({ mappings, toManyTree, conversionMapper, entry })
-
-      if (mappings[CLEANUP_KEYS]) {
-        for (const key of Object.keys(mappings[CLEANUP_KEYS])) delete parsed[key]
-      }
-
-      if (parsed) {
-        this._result.push(parsed)
-      }
-    }
-  }
-
-  _isExpandEmpty(mapping, result) {
-    for (const key in mapping) {
-      const el = mapping[key]
-      // if we expand automatically in groupby we have no other columns than objects
-      if (typeof el !== 'string') return false
-      if (result[el] !== null && !DRAFT_COLUMNS_ARRAY.some(col => el.endsWith(`_${col}`))) {
-        return false
-      }
-    }
-    return true
-  }
-
-  /**
-   * Takes one result row (entry) and converts it into expanded row according to the config at the structureMap.
-   *
-   * @param {object} config
-   * @param {Map} config.mappings - Config how to structure the entry. Can be nested which will lead to recursion.
-   * @param {Map} config.conversionMapper - Post processing of values like 1/0 to true/false.
-   * @param {object} config.entry - One row (entry) of the result set.
-   * @param {object} config.toManyTree - Tree of 'to many' associations.
-   * @returns {object}
-   * @private
-   */
-  _parseRaw({ mappings, toManyTree, conversionMapper, entry }) {
-    let isEntityNull
-
-    const row = {}
-
-    const rootIsActiveEntity = this._rootEntity._isDraftEnabled
-      ? mappings.IsActiveEntity
-        ? entry[mappings.IsActiveEntity] === null
-          ? null
-          : !!entry[mappings.IsActiveEntity]
-        : 'IsActiveEntity' in entry
-          ? entry.IsActiveEntity === null
-            ? null
-            : !!entry.IsActiveEntity
-          : null
-      : null
-
-    // A raw row contains more elements than the config. Iterating over config is faster.
-    for (const key in mappings) {
-      // To many entries have been already processed and cached
-      const mapping = mappings[key]
-      if (mapping[TO_MANY]) {
-        let expandedItems = this._getResultCache(toManyTree.concat(key))[mapping[GET_KEY_VALUE](false, entry)] || []
-
-        row[key] = !mapping[CLEANUP_KEYS]
-          ? expandedItems
-          : expandedItems.map(item => {
-              for (const key of Object.keys(mapping[CLEANUP_KEYS])) delete item[key]
-              return item
-            })
-      } else if (typeof mapping === 'object') {
-        // > Will be true in case of 1:1 expands
-        // check if the expanded entry doesn't exists
-        if (this._isExpandEmpty(mapping, entry)) {
-          row[key] = null
-          continue
-        }
-        const parsed = this._parseRaw({
-          mappings: mapping,
-          toManyTree: toManyTree.concat(key),
-          conversionMapper: conversionMapper,
-          entry: entry
-        })
-
-        // the expanded items may include the actives of the deleted drafts -> filter out
-        if (rootIsActiveEntity === null || key === 'DraftAdministrativeData') {
-          row[key] = parsed || null
-        } else if (rootIsActiveEntity !== null) {
-          if (mapping[TO_ACTIVE]) row[key] = parsed && parsed.IsActiveEntity !== false ? parsed : null
-          else if (rootIsActiveEntity) row[key] = parsed && parsed.IsActiveEntity !== false ? parsed : null
-          else row[key] = parsed && parsed.IsActiveEntity === rootIsActiveEntity ? parsed : null
-        }
-        if (parsed && mapping[CLEANUP_KEYS]) {
-          for (const key in mapping[CLEANUP_KEYS]) delete parsed[key]
-        }
-      } else {
-        // > No expand convert the result directly.
-        const rawValue = entry[mapping]
-        // Assume a DB will not return undefined, but always null
-        this._convertValue(rawValue, conversionMapper.get(mapping), mapping, row, key)
-
-        isEntityNull = this._isNull(isEntityNull, rawValue, key)
-      }
-    }
-
-    // No property holds any value. A to null must have failed.
-    if (isEntityNull) return
-
-    return row
-  }
-
-  /**
-   * Check if row entry is null.
-   *
-   * @param {boolean} isEntityNull - previous state
-   * @param {*} value - Value of row entry
-   * @returns {boolean}
-   * @private
-   */
-  _isNull(isEntityNull, value, key) {
-    if (isEntityNull === undefined) {
-      return value == null || key === 'IsActiveEntity'
-    }
-
-    return isEntityNull === true && (value == null || key === 'IsActiveEntity')
-  }
-
-  /**
-   * Helper to check if value needs to be converted and if yes, apply the conversion function.
-   *
-   * @param {string|number} value - As received from DB
-   * @param {Function} converter - To something (Boolean, String, ...) conversion
-   * @returns {*}
-   * @private
-   */
-  _convertValue(value, converter, key, row, unaliasedKey) {
-    if (converter) {
-      converter(value, key, row, unaliasedKey)
-      return
-    }
-
-    row[unaliasedKey || key] = value
-  }
-
-  _parseExpandResult(result, mappings, conversionMapper, toManyTree) {
-    const resultCache = this._getResultCache(toManyTree)
-    const expandMapping = this._getExpandMapping(mappings, toManyTree)
-
-    for (const entry of result) {
-      const parsed = this._parseRaw({ mappings: expandMapping, toManyTree, conversionMapper, entry })
-
-      if (parsed) {
-        const key = expandMapping[GET_KEY_VALUE](true, entry)
-
-        if (!resultCache[key]) {
-          resultCache[key] = []
-        }
-
-        resultCache[key].push(parsed)
-      }
-    }
-  }
-
-  _getResultCache(toManyTree) {
-    let target = this._toManyResults
-
-    for (const expand of toManyTree) {
-      if (!target[expand]) {
-        target[expand] = {
-          [EXPAND]: {}
-        }
-      }
-
-      target = target[expand]
-    }
-
-    return target
-  }
-
-  _getExpandMapping(mappings, toManyTree) {
-    let mapping = mappings
-
-    for (const key of toManyTree) {
-      mapping = mapping[key]
-    }
-
-    return mapping
-  }
-}
-
-/**
- * Convert N results into one expanded according to configurations.
- *
- * @param {Array} configs - Array of instructions how to combine and expand the 1 to N results
- * @param {Array} queries - Same amount of queries as configs. Contains one query for each to many expand.
- * @param {boolean} one - SELECT.one has been used
- * @param {object} rootEntity - the root entity
- * @returns {Promise<Array>} The complete expanded result set.
- */
-const rawToExpanded = (configs, queries, one, rootEntity) => {
-  return new RawToExpanded(configs, queries, one, rootEntity).toExpanded()
-}
-
-module.exports = rawToExpanded

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

@@ -1,30 +0,0 @@
-const InsertResult = require('../result/InsertResult')
-
-/**
- * Generic Handler for CREATE requests.
- * REVISIT: add description
- *
- * @param req - cds.Request
- */
-module.exports = async function (req) {
-  if (typeof req.query === 'string') {
-    const results = await this._execute.sql(this.dbc, req.query, req.data)
-    return Array.isArray(results) && results[0] != null && results[0].affectedRows != null
-      ? results[0].affectedRows
-      : results
-  }
-
-  try {
-    const results = await this._insert(this.model, this.dbc, req.query, req)
-    return new InsertResult(req, results)
-  } catch (err) {
-    // If entry is available, reject event
-    // REVISIT: db specifics
-    if (err.message.match(/unique constraint/i)) {
-      err.originalMessage = err.message
-      err.message = 'ENTITY_ALREADY_EXISTS'
-      err.code = 400
-    }
-    req.reject(err)
-  }
-}

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

@@ -1,18 +0,0 @@
-// REVISIT: DeleteResult
-// const DeleteResult = require('../result/DeleteResult')
-
-/**
- * Generic Handler for DELETE requests.
- * REVISIT: correct description?
- * In case of success it returns undefined.
- * If the entry to be deleted does not exist, it rejects with error 404.
- *
- * @param req - cds.Request
- */
-module.exports = function (req) {
-  if (typeof req.query === 'string') {
-    return this._execute.sql(this.dbc, req.query, req.data)
-  }
-
-  return this._delete(this.model, this.dbc, req.query, req)
-}

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

@@ -1,25 +0,0 @@
-// before
-const rewrite = require('./rewrite')
-const input = require('./input')
-const { convertVirtuals: virtual } = require('./virtual')
-// on
-const CREATE = require('./create')
-const READ = require('./read')
-const UPDATE = require('./update')
-const DELETE = require('./delete')
-// after
-const structured = require('./structured')
-
-/*
- * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
- */
-module.exports = {
-  rewrite,
-  virtual,
-  input,
-  CREATE,
-  READ,
-  UPDATE,
-  DELETE,
-  structured
-}

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

@@ -1,227 +0,0 @@
-/*
- * input handler on DatabaseService level
- *
- * - remove virtual fields
- * - add managed, if not provided
- * - assert not nullable without default (for better error message)
- * - add default values, if not provided (mainly for rest response body, odata does read after write)
- * - add UUIDs
- * - propagate keys
- */
-
-const cds = require('../../cds')
-
-const normalizeTimeData = require('../utils/normalizeTimeData')
-
-const { enrichDataWithKeysFromWhere } = require('../../common/utils/keys')
-const propagateForeignKeys = require('../../common/utils/propagateForeignKeys')
-const getTemplate = require('../../common/utils/template')
-
-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.isUUID
-
-const _processComplexCategory = ({ row, key, val, category, req, element }) => {
-  const categoryArgs = category.args
-  category = category.category
-
-  // propagate keys
-  if (category === 'propagateForeignKeys') {
-    if (req.event !== 'UPSERT')
-      propagateForeignKeys(key, row, element._foreignKeys, element.isComposition, { deleteAssocs: true })
-    return
-  }
-
-  // managed
-  if (val === undefined && _isManaged(category, req.event)) {
-    if (typeof categoryArgs === 'object') {
-      const val = categoryArgs['=']
-      if (val.match(/^\$/)) {
-        row[key] = val === '$uuid' ? cds.utils.uuid() : val
-      } else row[key] = row[val]
-    } else {
-      row[key] = categoryArgs
-    }
-  }
-
-  // not null with default for rest response body and ensure utc
-  if (category === 'default' && val === undefined && req.event === 'CREATE') {
-    const { default: dfault } = categoryArgs
-    if ('val' in dfault) row[key] = dfault.val
-    else if ('ref' in dfault && dfault.ref[0] === '$now') {
-      row[key] =
-        categoryArgs._type === 'cds.DateTime'
-          ? new Date(req.timestamp).toISOString().replace(/\.\d\d\d/, '')
-          : req.timestamp
-    }
-  }
-}
-
-const _processCategory = (req, category, { row, key, element }) => {
-  const val = row[key]
-
-  // use args only inside this if (sonar type error warning)
-  if (typeof category === 'object') {
-    _processComplexCategory({ category, row, key, val, req, element })
-    return
-  }
-
-  // virtual
-  if (category === 'virtual') {
-    delete row[key]
-    return
-  }
-
-  if (category === 'comp2one') {
-    if (!val) return
-
-    for (const keyName in element._target.keys) {
-      const k = element._target.keys[keyName]
-      if (k.isAssociation || k.name === 'IsActiveEntity') continue
-
-      if (!k.isUUID && !(k.name in val)) {
-        req.error({
-          code: 'MUST_NOT_BE_NULL',
-          message: 'Value is required',
-          target: key + '[' + k.name + ']',
-          args: [key + '[' + k.name + ']']
-        })
-        return
-      }
-    }
-  }
-
-  // not null without default (for better error message)
-  if (category === '!default' && val == null && req.event === 'CREATE') {
-    req.error({ code: 'MUST_NOT_BE_NULL', message: 'Value is required', target: key, args: [key] })
-    return
-  }
-
-  // generate UUIDs
-  if (category === 'uuid' && !val && req.event === 'CREATE' && !element._foreignKey4) {
-    row[key] = cds.utils.uuid()
-  }
-}
-
-const _processorFn = req => elementInfo => {
-  for (const category of elementInfo.plain.categories) {
-    _processCategory(req, category, elementInfo)
-  }
-}
-
-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 _pickCRUD = element => {
-  // collect actions to apply
-  const categories = []
-
-  if (_isVirtualOrCalculated(element)) {
-    categories.push('virtual')
-    return { categories } // > no need to continue
-  }
-
-  if (element.notNull && element['@assert.notNull'] !== false && !element.default && !element._isAssociationStrict) {
-    categories.push('!default')
-  }
-
-  if (element.default && !DRAFT_COLUMNS_MAP[element.name] && !element.isAssociation) {
-    categories.push({ category: 'default', args: element })
-  }
-
-  if (element['@cds.on.insert']) {
-    categories.push({ category: '@cds.on.insert', args: element['@cds.on.insert'] })
-  }
-
-  if (element['@cds.on.update']) {
-    categories.push({ category: '@cds.on.update', args: element['@cds.on.update'] })
-  }
-
-  // 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 (element.isComposition && element.is2one) {
-    categories.push('comp2one')
-  }
-
-  if (categories.length) return { categories }
-}
-
-const _pickDraft = element => {
-  // collect actions to apply
-  const categories = []
-
-  if (_isVirtualOrCalculated(element)) {
-    categories.push('virtual')
-    return { categories } // > no need to continue
-  }
-
-  if (element.default && !DRAFT_COLUMNS_MAP[element.name] && !element.isAssociation) {
-    categories.push({ category: 'default', args: element })
-  }
-
-  // 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 }
-}
-
-function dbGenericInput(req) {
-  if (!this.model || typeof req.query === 'string' || !req.target) return
-
-  // call with this for this.model
-  normalizeTimeData.call(this, req)
-
-  const draft = req.target.name && (req.target.name.match(/_drafts$/) || req.target.name.match(/\.drafts$/))
-
-  const target =
-    req.target._unresolved && req.target.name
-      ? this.model.definitions[req.target.name] || this.model.definitions[req.target.name.replace(/_drafts$/, '')]
-      : req.target
-  if (!target || target._unresolved) return
-
-  // REVISIT: probably need to filter for .columns/.rows combination as well
-  if (req.query.INSERT && !req.query.INSERT.entries) return
-
-  let template
-  if (draft) {
-    template = getTemplate('db-input-draft', this, target, { pick: _pickDraft })
-  } else {
-    template = getTemplate('db-input-crud', this, target, { pick: _pickCRUD })
-  }
-
-  if (template.elements.size === 0) return
-
-  if (!draft) enrichDataWithKeysFromWhere(req.data, req, this)
-
-  template.process(req.data, _processorFn(req))
-}
-
-dbGenericInput._initial = true
-
-module.exports = dbGenericInput

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

@@ -1,16 +0,0 @@
-// REVISIT: ReadResult
-// const ReadResult = require('../result/ReadResult')
-
-/**
- * Generic Handler for READ requests.
- * REVISIT: add description
- *
- * @param req - cds.Request
- */
-module.exports = function (req) {
-  if (typeof req.query === 'string') {
-    return this._execute.sql(this.dbc, req.query, req.data)
-  }
-
-  return this._read(this.model, this.dbc, req.query, req)
-}

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

@@ -1,68 +0,0 @@
-const cds = require('../../cds')
-const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
-const { generateAliases } = require('../utils/generateAliases')
-
-/**
- * Restores the link of `req.data` and `req.query` in case `req.query` was overwritten.
- * Only applicable for `UPDATE`s and `INSERT`s.
- *
- * @param { import('@sap/cds').Request } req
- */
-const _restoreLink = req => {
-  if (req.query.INSERT?.entries) {
-    if (Array.isArray(req.query.INSERT.entries)) req.data = req.query.INSERT.entries[0]
-    else req.data = req.query.INSERT.entries
-  } else if (req.query.UPDATE?.data) {
-    req.data = req.query.UPDATE.data
-  }
-}
-
-const _isLinked = req => {
-  if (req.query.INSERT?.entries) {
-    // in case of more than one entry, the array reference stays in tact
-    if (Array.isArray(req.query.INSERT.entries)) return req.data === req.query.INSERT.entries[0]
-    return req.data === req.query.INSERT.entries
-  }
-
-  if (req.query.UPDATE?.data) {
-    return req.data === req.query.UPDATE.data
-  }
-
-  return false
-}
-
-function handler(req) {
-  if (typeof req.query === 'string') return
-
-  // invoke req.subject and req.query.elements before it gets modified
-  req.subject
-  try {
-    req.query.elements
-  } catch {
-    // ignore potential errors (no x4 support in req.query.elements)
-  }
-
-  if (!this.model) {
-    // best-effort rewrite of path in from
-    req.query = cqn2cqn4sql(req.query, { definitions: {} }, { service: this })
-    return
-  }
-
-  const _streaming = cds.env.features.stream_compat && req.query._streaming
-
-  // for restore link to req.data
-  const linked = _isLinked(req)
-
-  // convert to sql cqn
-  req.query = cqn2cqn4sql(req.query, this.model, { service: this })
-
-  // REVISIT: should not be necessary
-  // restore link to req.data
-  if (linked) _restoreLink(req)
-
-  if (_streaming) req.query._streaming = _streaming
-  generateAliases(req.query)
-}
-
-handler._initial = true
-module.exports = handler