@sap/cds 8.9.4 → 9.0.2

package/libx/_runtime/common/error/index.js

@@ -1,12 +0,0 @@
-const entry = require('./entry')
-
-module.exports = (...args) => {
-  let e = entry(...args)
-  if (!(e instanceof Error)) e = Object.assign(new Error(e.message), e)
-  // _thrownByFramework shouldn't be logged
-  Object.defineProperty(e, '_thrownByFramework', {
-    value: true,
-    enumerable: false
-  })
-  return e
-}

package/libx/_runtime/common/error/log.js

@@ -1,35 +0,0 @@
-// REVISIT: I think we can remove this file. Log output doesn't need localization.
-// REVISIT: We should remove the i18n machinery from log output.
-const cds = require('../../cds')
-const LOG = cds.log()
-
-const { isClientError } = require('./frontend')
-
-// REVISIT: Where is that being used...?
-module.exports = err => {
-  // REVISIT: how does level behave compared to _log in (legacy) odata adapter?
-  const level = isClientError(err) ? 'warn' : 'error'
-  if ((level === 'warn' && !LOG._warn) || (level === 'error' && !LOG._error)) return
-
-  // replace messages in toLog with developer texts (i.e., undefined locale)
-  const _message = err.message
-  const _details = err.details
-  // REVISIT: We shouldn't run log output thru i18n machinery at all!
-  err.message = cds.i18n.messages.at(err.message || err.code, '', err.args) || err.message
-  if (err.details) {
-    const details = []
-    for (const d of err.details) {
-      details.push(
-        Object.assign({}, d, { message: cds.i18n.messages.at(d.message || d.code, '', d.args) || d.message })
-      )
-    }
-    err.details = details
-  }
-
-  // log it
-  LOG[level](err)
-
-  // restore
-  err.message = _message
-  if (_details) err.details = _details
-}

package/libx/_runtime/common/error/standardError.js

@@ -1,11 +0,0 @@
-const isStandardError = err => {
-  return (
-    err instanceof TypeError ||
-    err instanceof ReferenceError ||
-    err instanceof SyntaxError ||
-    err instanceof RangeError ||
-    err instanceof URIError
-  )
-}
-
-module.exports = { isStandardError }

package/libx/_runtime/common/error/utils.js

@@ -1,18 +0,0 @@
-const { i18n } = require('../../../../lib')
-
-/**
- * Gets the localized error message for an error based on message, code, statusCode or status
- * @param {*} error
- * @param {*} locale can be undefined for default language
- * @returns localized error message
- */
-// REVISIT: Where is that being used...?
-function getErrorMessage(error, locale) {
-  const key = error.message || error.code || error.status || error.statusCode || '500'
-  const txt = i18n.messages.at(key, locale, error.args)
-  return txt || error.message || String(error.code || error.status || error.statusCode)
-}
-
-module.exports = {
-  getErrorMessage
-}

package/libx/_runtime/common/generic/auth/constants.js

@@ -1,17 +0,0 @@
-const { MOD_EVENTS, WRITE_EVENTS, CRUD_EVENTS, DRAFT_EVENTS } = require('../../constants/events')
-
-const RESTRICTIONS = {
-  CREATE: 'InsertRestrictions.Insertable',
-  READ: 'ReadRestrictions.Readable',
-  READABLE_BY_KEY: 'ReadRestrictions.ReadByKeyRestrictions.Readable',
-  UPDATE: 'UpdateRestrictions.Updatable',
-  DELETE: 'DeleteRestrictions.Deletable'
-}
-
-module.exports = {
-  MOD_EVENTS,
-  WRITE_EVENTS,
-  CRUD_EVENTS,
-  DRAFT_EVENTS,
-  RESTRICTIONS
-}

package/libx/_runtime/common/generic/put.js

@@ -1,85 +0,0 @@
-/*
- * additional input handler on ApplicationService level for PUT
- *
- * - add default value or null (if nullable) for each property that was not provided
- *   and is neither key nor read-only (e.g., managed, virtual, etc.)
- */
-
-const cds = require('../../cds')
-const getTemplate = require('../utils/template')
-const { getDataFromCQN, setDataFromCQN } = require('../utils/data')
-
-const _fillStructure = (row, parts, element, category, args) => {
-  if (parts.length === 1) {
-    if (row[parts[0]] === undefined) {
-      row[parts[0]] = (args && args.val) || null
-    }
-  } else {
-    if (row[parts[0]] === undefined) {
-      row[parts[0]] = {}
-    }
-    _fillStructure(row[parts[0]], parts.slice(1), element, category, args)
-  }
-}
-
-const _getProcessorFn = req => {
-  const REST = req.protocol === 'rest'
-
-  return ({ row, key, element, plain }) => {
-    if (!row || row[key] !== undefined) return
-
-    const { category, args } = plain
-
-    // fills non-navigation structures if REST
-    if (REST && element.name.match(/._./)) {
-      const parts = element.name.split('_')
-      if (!element.parent.elements[parts[0]]) {
-        _fillStructure(row, parts, element, category, args)
-        return
-      }
-    }
-
-    if (category === 'default') {
-      row[key] = args.val
-    } else if (category === 'null' && !element._isStructured) {
-      row[key] = null
-    }
-  }
-}
-
-const _pick = element => {
-  if (!element.isAssociation && !element.key && !element._isReadOnly) {
-    if (element.default) return { category: 'default', args: element.default }
-    if (!element.notNull) return { category: 'null' }
-  }
-}
-
-function commonGenericPut(req) {
-  if (req.method !== 'PUT') return
-  if (!req.query) return // FIXME: the code below expects req.query to be defined
-  if (!req.target) return
-
-  // not for payloads with stream properties
-  const { elements } = req.target
-  for (const k in req.data) if (k in elements && elements[k]['@Core.MediaType']) return
-
-  const template = getTemplate('app-put', this, req.target, {
-    pick: _pick,
-    ignore: element => element._isAssociationStrict
-  })
-  if (template.elements.size === 0) return
-
-  // REVISIT: req.data should point into req.query
-  const data = getDataFromCQN(req.query)
-
-  template.process(data, _getProcessorFn(req))
-
-  // REVISIT: req.data should point into req.query
-  setDataFromCQN(req)
-}
-
-commonGenericPut._initial = true
-
-module.exports = cds.service.impl(function () {
-  this.before(['UPDATE'], '*', commonGenericPut)
-})

package/libx/_runtime/common/utils/columns.js

@@ -1,177 +0,0 @@
-const cds = require('../../cds')
-
-const { DRAFT_COLUMNS_UNION_MAP } = require('../constants/draft')
-const DEFAULT_SEARCHABLE_TYPE = 'cds.String'
-
-// REVISIT: Can we combine that with db/utils/columns.js?
-/**
- * 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 {import('@sap/cds-compiler/lib/api/main').CSN} 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_MAP) 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 calculated fields)
-    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)
-  }
-
-  // REVISIT: deprecated behavior => remove interpretation of the @Search.defaultSearchElement
-  // annotation after grace period
-  //
-  // For performance reasons, by default, only elements typed as strings are searchable unless
-  // the @cds.search annotation is specified, which at this point, we know that the @cds.search
-  // annotation is not specified.
-  const defaultSearchElementTerm = '@Search.defaultSearchElement'
-  const defaultSearchFilteredColumns = searchableColumns.filter(column => column[defaultSearchElementTerm])
-
-  if (defaultSearchFilteredColumns.length > 0) {
-    // Remove with cds^8
-    cds.utils.deprecated({
-      kind: 'Annotation',
-      old: '@Search.defaultSearchElement in entity ' + entity.name,
-      use: '@cds.search'
-    })
-    return defaultSearchFilteredColumns.map(column => column.name)
-  }
-
-  return searchableColumns.map(column => column.name)
-}
-
-/**
- * @returns {import('../../types/api').ColumnRefs}
- */
-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/libx/_runtime/common/utils/compareJsonOLD.js

@@ -1,280 +0,0 @@
-// copied from @sap/cds@8.3.1
-
-const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
-
-const _deepEqual = (val1, val2) => {
-  if (val1 && typeof val1 === 'object' && val2 && typeof val2 === 'object') {
-    for (const key in val1) {
-      if (!_deepEqual(val1[key], val2[key])) return false
-    }
-    return true
-  }
-  return val1 === val2
-}
-
-const _getCorrespondingEntryWithSameKeys = (source, entry, keys) => {
-  const idx = _getIdxCorrespondingEntryWithSameKeys(source, entry, keys)
-  return idx !== -1 ? source[idx] : undefined
-}
-
-const _getIdxCorrespondingEntryWithSameKeys = (source, entry, keys) =>
-  source.findIndex(sourceEntry => keys.every(key => _deepEqual(sourceEntry[key], entry[key])))
-
-const _getKeysOfEntity = entity =>
-  Object.keys(entity.keys).filter(key => !(key in DRAFT_COLUMNS_MAP) && !entity.elements[key].isAssociation)
-
-const _getCompositionsOfEntity = entity => Object.keys(entity.elements).filter(e => entity.elements[e].isComposition)
-
-const _createToBeDeletedEntries = (oldEntry, entity, keys, compositions) => {
-  const toBeDeletedEntry = {
-    _op: 'delete'
-  }
-
-  for (const prop in oldEntry) {
-    if (prop in DRAFT_COLUMNS_MAP) {
-      continue
-    }
-    if (keys.includes(prop)) {
-      toBeDeletedEntry[prop] = oldEntry[prop]
-    } else if (compositions.includes(prop) && oldEntry[prop]) {
-      toBeDeletedEntry[prop] = entity.elements[prop].is2one
-        ? _createToBeDeletedEntries(
-            oldEntry[prop],
-            entity.elements[prop]._target,
-            _getKeysOfEntity(entity.elements[prop]._target),
-            _getCompositionsOfEntity(entity.elements[prop]._target)
-          )
-        : oldEntry[prop].map(entry =>
-            _createToBeDeletedEntries(
-              entry,
-              entity.elements[prop]._target,
-              _getKeysOfEntity(entity.elements[prop]._target),
-              _getCompositionsOfEntity(entity.elements[prop]._target)
-            )
-          )
-    } else {
-      toBeDeletedEntry._old = toBeDeletedEntry._old || {}
-      toBeDeletedEntry._old[prop] = oldEntry[prop]
-    }
-  }
-
-  return toBeDeletedEntry
-}
-
-const _hasOpDeep = (entry, element) => {
-  const entryArray = Array.isArray(entry) ? entry : [entry]
-  for (const entry_ of entryArray) {
-    if (entry_._op) return true
-
-    if (element && element.isComposition) {
-      const target = element._target
-      for (const prop in entry_) {
-        if (_hasOpDeep(entry_[prop], target.elements[prop])) {
-          return true
-        }
-      }
-    }
-  }
-
-  return false
-}
-
-const _addCompositionsToResult = (result, entity, prop, newValue, oldValue, opts) => {
-  /*
-   * REVISIT: the current impl results in {} instead of keeping null for compo to one.
-   *          unfortunately, many follow-up errors occur (e.g., prop in null checks) if changed.
-   */
-  let composition
-  if (
-    newValue[prop] &&
-    typeof newValue[prop] === 'object' &&
-    !Array.isArray(newValue[prop]) &&
-    Object.keys(newValue[prop]).length === 0
-  ) {
-    composition = compareJsonDeep(entity.elements[prop]._target, undefined, oldValue && oldValue[prop], opts)
-  } else {
-    composition = compareJsonDeep(entity.elements[prop]._target, newValue[prop], oldValue && oldValue[prop], opts)
-  }
-  if (composition.some(c => _hasOpDeep(c, entity.elements[prop]))) {
-    result[prop] = entity.elements[prop].is2one ? composition[0] : composition
-  }
-}
-
-const _addPrimitiveValuesAndOperatorToResult = (result, prop, newValue, oldValue) => {
-  result[prop] = newValue[prop]
-
-  if (!result._op) {
-    result._op = oldValue ? 'update' : 'create'
-  }
-
-  if (result._op === 'update') {
-    result._old = result._old || {}
-    result._old[prop] = oldValue[prop]
-  }
-}
-
-const _addKeysToResult = (result, prop, newValue, oldValue) => {
-  result[prop] = newValue[prop]
-  if (!oldValue) {
-    result._op = 'create'
-  }
-}
-
-const _addToBeDeletedEntriesToResult = (results, entity, keys, newValues, oldValues) => {
-  // add to be deleted entries
-  for (const oldEntry of oldValues) {
-    const entry = _getCorrespondingEntryWithSameKeys(newValues, oldEntry, keys)
-
-    if (!entry) {
-      // prepare to be deleted (deep) entry without manipulating oldData
-      const toBeDeletedEntry = _createToBeDeletedEntries(oldEntry, entity, keys, _getCompositionsOfEntity(entity))
-      results.push(toBeDeletedEntry)
-    }
-  }
-}
-
-const _normalizeToArray = value => (Array.isArray(value) ? value : value === null ? [] : [value])
-
-const _isUnManaged = element => {
-  return element.on && !element._isSelfManaged
-}
-
-const _skip = (entity, prop) => entity.elements[prop]._target._hasPersistenceSkip
-
-const _skipToOne = (entity, prop) => {
-  return (
-    entity.elements[prop] && entity.elements[prop].is2one && _skip(entity, prop) && _isUnManaged(entity.elements[prop])
-  )
-}
-
-const _skipToMany = (entity, prop) => {
-  return entity.elements[prop] && entity.elements[prop].is2many && _skip(entity, prop)
-}
-
-// Returns all property names from the new entry and add missing managed elements
-const _propertiesAndManaged = (newEntry, entity) => {
-  return [
-    ...Object.getOwnPropertyNames(newEntry),
-    ...Object.keys(entity.elements).filter(
-      elementName => newEntry[elementName] === undefined && entity.elements[elementName]['@cds.on.update']
-    )
-  ]
-}
-
-const _iteratePropsInNewEntry = (newEntry, keys, result, oldEntry, entity, opts) => {
-  // On app-service layer, generated foreign keys are not enumerable,
-  // include them here too.
-  for (const prop of _propertiesAndManaged(newEntry, entity)) {
-    if (keys.includes(prop)) {
-      _addKeysToResult(result, prop, newEntry, oldEntry)
-      continue
-    }
-
-    // if value did not change --> ignored
-    if (
-      newEntry[prop] === (oldEntry && oldEntry[prop]) ||
-      (oldEntry && entity.elements[prop]?.['@Core.Immutable']) ||
-      (opts.ignoreDraftColumns && prop in DRAFT_COLUMNS_MAP)
-    ) {
-      continue
-    }
-
-    if (_skipToMany(entity, prop)) {
-      continue
-    }
-
-    if (_skipToOne(entity, prop)) {
-      continue
-    }
-
-    if (entity.elements[prop] && entity.elements[prop].isComposition) {
-      _addCompositionsToResult(result, entity, prop, newEntry, oldEntry, opts)
-      continue
-    }
-
-    _addPrimitiveValuesAndOperatorToResult(result, prop, newEntry, oldEntry)
-  }
-}
-
-const compareJsonDeep = (entity, newValue = [], oldValue = [], opts) => {
-  const resultsArray = []
-  const keys = _getKeysOfEntity(entity)
-
-  // normalize input
-  const newValues = _normalizeToArray(newValue)
-  const oldValues = _normalizeToArray(oldValue)
-
-  // add to be created and to be updated entries
-  for (const newEntry of newValues) {
-    const result = {}
-    const oldEntry = _getCorrespondingEntryWithSameKeys(oldValues, newEntry, keys)
-    _iteratePropsInNewEntry(newEntry, keys, result, oldEntry, entity, opts)
-    resultsArray.push(result)
-  }
-
-  _addToBeDeletedEntriesToResult(resultsArray, entity, keys, newValues, oldValues)
-
-  return resultsArray
-}
-
-/**
- * Compares newValue with oldValues in a deep fashion.
- * Output format is newValue with additional administrative properties.
- * - "_op" provides info about the CRUD action to perform
- * - "_old" provides info about the current DB state
- *
- * Unchanged values are not part of the result.
- *
- * Output format is:
- * {
- *   _op: 'update',
- *   _old: { orderedAt: 'DE' },
- *   ID: 1,
- *   orderedAt: 'EN',
- *   items: [
- *     {
- *       _op: 'update',
- *       _old: { amount: 7 },
- *       ID: 7,
- *       amount: 8
- *     },
- *     {
- *       _op: 'create',
- *       ID: 8,
- *       amount: 8
- *     },
- *     {
- *       _op: 'delete',
- *       _old: {
- *         amount: 6
- *       },
- *       ID: 6
- *     }
- *   ]
- * }
- *
- *
- * If there is no change in an UPDATE, result is an object containing only the keys of the entity.
- *
- * @example
- * compareJson(csnEntity, [{ID: 1, col1: 'A'}], [{ID: 1, col1: 'B'}])
- *
- * @param oldValue
- * @param {object} entity
- * @param {Array | object} newValue
- * @param {Array} oldValues
- *
- * @returns {Array}
- */
-const compareJson = (newValue, oldValue, entity, opts = {}) => {
-  const options = Object.assign({ ignoreDraftColumns: false }, opts)
-  const result = compareJsonDeep(entity, newValue, oldValue, options)
-
-  // in case of batch insert, result is an array
-  // in all other cases it is an array with just one entry
-  return Array.isArray(newValue) ? result : result[0]
-}
-
-module.exports = {
-  compareJson
-}