@sap/cds 9.1.0 → 9.2.0

package/libx/_runtime/cds-services/util/assert.js

@@ -1,181 +0,0 @@
-const cds = require('../../cds')
-const LOG = cds.log('app')
-const templatePathSerializer = require('../../common/utils/templateProcessorPathSerializer')
-
-const typeCheckers = require('../../../common/assert/type-strict')
-const { 'cds.Decimal': checkDecimal } = typeCheckers
-const { checkMandatory, checkEnum, checkRange, checkFormat } = require('../../../common/assert/validation')
-
-const ASSERT_RANGE = 'ASSERT_RANGE'
-const ASSERT_FORMAT = 'ASSERT_FORMAT'
-const ASSERT_DATA_TYPE = 'ASSERT_DATA_TYPE'
-const ASSERT_ENUM = 'ASSERT_ENUM'
-const ASSERT_NOT_NULL = 'ASSERT_NOT_NULL'
-
-const _enumValues = element => {
-  return Object.keys(element).map(enumKey => {
-    const enum_ = element[enumKey]
-    const enumValue = enum_ && enum_.val
-
-    if (enumValue !== undefined) {
-      if (enumValue['=']) return enumValue['=']
-      if (enum_ && enum_.literal && enum_.literal === 'number') return Number(enumValue)
-      return enumValue
-    }
-
-    return enumKey
-  })
-}
-
-// REVISIT: this needs a cleanup!
-const assertError = (code, element, value, key, path) => {
-  let args
-
-  if (typeof code === 'object') {
-    args = code.args
-    code = code.code
-  }
-
-  const { name, type, precision, scale } = element
-  const error = new Error()
-  const errorEntry = {
-    code,
-    message: code,
-    target: path ?? element.name ?? key,
-    args: args ?? [name ?? key]
-  }
-
-  const assertError = Object.assign(error, errorEntry)
-  Object.assign(assertError, {
-    entity: element.parent && element.parent.name,
-    element: name, // > REVISIT: when is error.element needed?
-    type: element.items ? element.items._type : type,
-    status: 400,
-    value
-  })
-
-  if (element.enum) assertError.enum = _enumValues(element)
-  if (precision) assertError.precision = precision
-  if (scale) assertError.scale = scale
-
-  if (element.target) {
-    // REVISIT: when does this case apply?
-    assertError.target = element.target
-  }
-
-  return assertError
-}
-
-/**
- * @param {import('../../types/api').InputConstraints} constraints
- */
-const checkInputConstraints = ({ element, value, errors, key, pathSegmentsInfo }) => {
-  if (!element) return errors
-
-  let path
-  if (pathSegmentsInfo?.length) path = templatePathSerializer(element.name || key, pathSegmentsInfo)
-
-  // not nice, but best option for keeping new cds.assert() clean
-  if (element._isMandatory) {
-    const mandatoryErrors = []
-    checkMandatory(value, element, mandatoryErrors, [], key)
-    if (mandatoryErrors.length) {
-      errors.push(...mandatoryErrors.map(() => assertError({ code: ASSERT_NOT_NULL }, element, value, key, path)))
-    }
-  }
-
-  if (value == null) return errors
-
-  // not nice, but best option for keeping new cds.assert() clean
-  const enumErrors = []
-  checkEnum(value, element, enumErrors, [], key)
-  if (enumErrors.length) {
-    errors.push(...enumErrors.map(e => assertError({ code: ASSERT_ENUM, args: e.args }, element, value, key, path)))
-  }
-
-  // not nice, but best option for keeping new cds.assert() clean
-  const rangeErrors = []
-  checkRange(value, element, rangeErrors, [], key)
-  if (rangeErrors.length) {
-    errors.push(...rangeErrors.map(e => assertError({ code: ASSERT_RANGE, args: e.args }, element, value, key, path)))
-  }
-
-  // not nice, but best option for keeping new cds.assert() clean
-  const formatErrors = []
-  checkFormat(value, element, formatErrors, [], key)
-  if (formatErrors.length) {
-    errors.push(...formatErrors.map(e => assertError({ code: ASSERT_FORMAT, args: e.args }, element, value, key, path)))
-  }
-
-  if (element.type === 'cds.Decimal') {
-    // not nice, but best option for keeping new cds.assert() clean
-    const decimalErrors = []
-    checkDecimal(value, element, decimalErrors, [], key)
-    if (decimalErrors.length) {
-      errors.push(
-        ...decimalErrors.map(e => assertError({ code: ASSERT_DATA_TYPE, args: e.args }, element, value, key, path))
-      )
-    }
-  }
-
-  return errors
-}
-
-/**
- * Check whether the target entity referenced by the association (the reference's target) exists and assert an error if
- * the the reference's target doesn't exist.
- *
- * In other words, use this annotation to check whether a non-null foreign key input in a table has a corresponding
- * primary key (also known as a parent key) in the associated/referenced target table (also known as a parent table).
- *
- * @param {import('../../types/api').assertTargetMap} assertMap
- * @param {array} errors An array to appends the possible errors.
- * @see {@link https://cap.cloud.sap/docs/guides/providing-services#assert-target @assert.target} for
- * further information.
- */
-const assertTargets = async (assertMap, errors) => {
-  const { targets: targetsMap, allTargets } = assertMap
-  if (targetsMap.size === 0) return
-
-  const targets = Array.from(targetsMap.values())
-  const transactions = targets.map(({ keys, entity }) => {
-    const where = Object.assign({}, ...keys)
-    return cds.db.exists(entity, where).forShareLock()
-  })
-  const targetsExistsResults = await Promise.allSettled(transactions)
-
-  targetsExistsResults.forEach((txPromise, index) => {
-    const isPromiseRejected = txPromise.status === 'rejected'
-    const shouldAssertError = (txPromise.status === 'fulfilled' && txPromise.value == null) || isPromiseRejected
-    if (!shouldAssertError) return
-
-    const target = targets[index]
-    const { element } = target.assocInfo
-
-    if (isPromiseRejected) {
-      LOG._debug &&
-        LOG.debug(
-          `The transaction to check the @assert.target constraint for foreign key "${element.name}" failed`,
-          txPromise.reason
-        )
-
-      throw new Error(txPromise.reason.message)
-    }
-
-    allTargets
-      .filter(t => t.key === target.key)
-      .forEach(target => {
-        const { row, pathSegmentsInfo } = target.assocInfo
-        const key = target.foreignKey.name
-        let path
-        if (pathSegmentsInfo?.length) path = templatePathSerializer(key, pathSegmentsInfo)
-        const error = assertError('ASSERT_TARGET', target.foreignKey, row[key], key, path)
-        errors.push(error)
-      })
-  })
-}
-
-module.exports = {
-  checkInputConstraints,
-  assertTargets
-}

package/libx/_runtime/types/api.js

@@ -1,129 +0,0 @@
-// Columns
-
-/**
- * @typedef {object} ColumnRef
- * @property {string[]} ref
- * @property {function} func
- */
-
-/**
- * @typedef {Array<ColumnRef>} ColumnRefs
- */
-
-// Input constraints
-
-/**
- * @typedef {object} InputConstraints
- * @property {object} element
- * @property {*} value
- * @property {Array} errors
- * @property {string} [key]
- * @property {pathSegmentInfo[]} [pathSegmentsInfo]
- * @property {string} event
- */
-
-// ON condition
-
-/**
- * @typedef {object} ONConditionAliases
- * @property {string} select
- * @property {string} join
- */
-
-/**
- * @typedef {object} ONConditionOptions
- * @property {string | Array} [associationNames]
- * @property {object} [csn]
- * @property {ONConditionAliases} [aliases]
- * @property {boolean} [resolveView=true]
- */
-
-// Template processor
-
-/**
- * @typedef {object} TemplateProcessorInfo
- * @property {entity} target
- * @property {Map} elements
- */
-
-/**
- * @typedef {object} TemplateProcessorPathOptions
- * @property {object} [draftKeys]
- * @property {function} [rowUUIDGenerator]
- * @property {string[]} [segments=[]] - Path segments to relate the error message.
- * @property {boolean} [includeKeyValues=false] Indicates whether the key values are included in the path segments
- * The path segments are used to build the error target (a relative resource path)
- */
-
-/**
- * @typedef {object} TemplateProcessor
- * @property {Function} processFn
- * @property {object} data
- * @property {TemplateProcessorInfo} template
- * @property {boolean} [isRoot=true]
- * @property {TemplateProcessorPathOptions} [pathOptions=null]
- */
-
-/**
- * @typedef {object} pathSegmentInfo
- * @property {string} key
- * @property {string[]} keyNames
- * @property {object} row
- * @property {object} elements
- * @property {string[]} draftKeys
- */
-
-/**
- * @typedef {object} templateElementInfo
- * @property {object} row
- * @property {string} key
- * @property {object} element
- * @property {boolean} plain
- * @property {entity} target
- * @property {boolean} isRoot
- * @property {string[] | Array<pathSegmentInfo>} [pathSegmentsInfo]
- */
-
-// Search
-
-/**
- * @typedef {object} searchContainsArg
- * @property {ColumnRefs} [list] The columns to
- * be searched
- * @property {string} [val] The search string
- */
-
-/**
- * @typedef {Array<searchContainsArg>} searchContainsArgs
- */
-
-/**
- * @typedef {object} searchContainsExp
- * @property {string} func='contains' The function name
- * @property {searchContainsArgs} args
- */
-
-/**
- * @typedef {object} search2cqnOptions
- * @property {ColumnRefs} [columns] The columns to be searched
- * @property {string} locale The user locale
- */
-
-// Assert targets map
-
-/**
- * @typedef {object} assertTargetMap
- * @property {Map<string, targetMaps>} targets
- * @property {targetMaps[]} allTargets
- */
-
-/**
- * @typedef {object} targetMaps
- * @property {string} key
- * @property {entity} entity
- * @property {object} keys
- * @property {object} foreignKey
- * @property {templateElementInfo} assocInfo
- */
-
-module.exports = {}

package/libx/common/assert/validation.js

@@ -1,109 +0,0 @@
-const { cds } = global
-
-const {
-  'cds.Date': checkISODate,
-  'cds.Time': checkISOTime,
-  'cds.DateTime': checkISODateTime,
-  'cds.Timestamp': checkISOTimestamp,
-  'cds.String': checkString
-} = require('./type-strict')
-const { getTarget, resolveCDSType } = require('./utils')
-
-const _isNavigationColumn = (col, as) => col.ref?.length > 1 && (col.as === as || col.ref[col.ref.length - 1] === as)
-
-// REVISIT: mandatory is actually not the same as not null or empty string
-const _isNotFilled = val => val === null || val === undefined || (typeof val === 'string' && val.trim() === '')
-
-const _getEnumElement = ele => ((ele['@assert.range'] && ele.enum) ? ele.enum : undefined)
-
-const _enumValues = ele => {
-  return Object.keys(ele).map(enumKey => {
-    const enum_ = ele[enumKey]
-    const enumValue = enum_ && enum_.val
-    if (enumValue !== undefined) {
-      if (enumValue['=']) return enumValue['=']
-      if (enum_ && enum_.literal && enum_.literal === 'number') return Number(enumValue)
-      return enumValue
-    }
-    return enumKey
-  })
-}
-
-const _checkDateValue = (val, r1, r2) => {
-  const dateVal = new Date(val)
-  return (dateVal - new Date(r1)) * (dateVal - new Date(r2)) <= 0
-}
-
-const _toDate = val => `2000-01-01T${val}Z`
-
-const _checkInRange = (val, range, type) => {
-  switch (type) {
-    case 'cds.Date':
-      return checkISODate(val) && _checkDateValue(val, range[0], range[1])
-    case 'cds.DateTime':
-      return checkISODateTime(val) && _checkDateValue(val, range[0], range[1])
-    case 'cds.Timestamp':
-      return checkISOTimestamp(val) && _checkDateValue(val, range[0], range[1])
-    case 'cds.Time':
-      return checkISOTime(val) && _checkDateValue(_toDate(val), _toDate(range[0]), _toDate(range[1]))
-    default:
-      return (val - range[0]) * (val - range[1]) <= 0
-  }
-}
-
-// process.env.CDS_ASSERT_FORMAT_FLAGS is not official!
-const _checkRegExpFormat = (val, format) =>
-  checkString(val) && val.match(new RegExp(format, process.env.CDS_ASSERT_FORMAT_FLAGS || 'u'))
-
-const checkMandatory = (v, ele, errs, path, k) => {
-  // REVISIT: correct to not complain?
-  // do not complain about missing foreign keys in children
-  if (path.length && ele['@odata.foreignKey4']) return
-
-  // TODO: which case is this?
-  // do not complain about ???
-  if (ele.parent?.query?.SELECT?.columns?.find(col => _isNavigationColumn(col, ele.name))) return
-
-  if (_isNotFilled(v)) {
-    const target = getTarget(path, k)
-    errs.push(new cds.error('ASSERT_NOT_NULL', { target, statusCode: 400, code: '400' }))
-  }
-}
-
-const checkEnum = (v, ele, errs, path, k) => {
-  const enumElements = _getEnumElement(ele)
-  const enumValues = enumElements && _enumValues(enumElements)
-  if (enumElements && !enumValues.some(ev => ev == v)) { //> use == for automatic type coercion
-    const args =
-      typeof v === 'string'
-        ? ['"' + v + '"', enumValues.map(ele => '"' + ele + '"').join(', ')]
-        : [v, enumValues.join(', ')]
-    const target = getTarget(path, k)
-    errs.push(new cds.error('ASSERT_ENUM', { args, target, statusCode: 400, code: '400' }))
-  }
-}
-
-const checkRange = (v, ele, errs, path, k) => {
-  const rangeElements = ele['@assert.range'] && !_getEnumElement(ele) ? ele['@assert.range'] : undefined
-  if (rangeElements && !_checkInRange(v, rangeElements, resolveCDSType(ele))) {
-    const args = [v, ...ele['@assert.range']]
-    const target = getTarget(path, k)
-    errs.push(new cds.error('ASSERT_RANGE', { args, target, statusCode: 400, code: '400' }))
-  }
-}
-
-const checkFormat = (v, ele, errs, path, k) => {
-  const formatElements = ele['@assert.format']
-  if (formatElements && !_checkRegExpFormat(v, formatElements)) {
-    const args = [v, formatElements]
-    const target = getTarget(path, k)
-    errs.push(new cds.error('ASSERT_FORMAT', { args, target, statusCode: 400, code: '400' }))
-  }
-}
-
-module.exports = {
-  checkMandatory,
-  checkEnum,
-  checkRange,
-  checkFormat
-}