@sap/cds 7.9.4 → 8.0.4

package/libx/_runtime/fiori/utils/where.js

@@ -1,254 +0,0 @@
-const AND_OR = { and: 1, or: 1 }
-
-const _removeMultipleBrackets = (index, whereCondition, isXpr) => {
-  if (isXpr) return index
-
-  let resIndex = index
-  if (whereCondition[index - 1] === '(') {
-    while (resIndex - 2 >= 0 && whereCondition[resIndex - 2] === '(') {
-      const indexClose = whereCondition.findIndex((element, elementIndex) => element === ')' && elementIndex > index)
-
-      if (whereCondition[indexClose + 1] === ')') {
-        whereCondition.splice(indexClose + 1, 1)
-        whereCondition.splice(resIndex - 2, 1)
-        resIndex--
-      } else {
-        break
-      }
-    }
-  }
-
-  return resIndex
-}
-
-const _calculateSpliceArgs = (index, whereCondition, isXpr = false) => {
-  const len = isXpr ? 1 : 3
-  if (whereCondition[index - 1] in AND_OR) {
-    return { index: index - 1, count: 1 + len }
-  }
-
-  if (whereCondition[index + len] in AND_OR) {
-    return { index: index, count: len + 1 }
-  }
-
-  if (whereCondition[index - 1] === '(' && whereCondition[index + len] === ')') {
-    if (whereCondition[index - 2] in AND_OR) {
-      return { index: index - 2, count: len + 3 }
-    }
-
-    if (whereCondition[index + len + 1] in AND_OR) {
-      return { index: index - 1, count: len + 3 }
-    }
-
-    return { index: index - 1, count: len + 2 }
-  }
-
-  return { index: index, count: len }
-}
-
-const _isActiveEntity = entry => entry.ref && entry.ref[entry.ref.length - 1] === 'IsActiveEntity'
-
-const _removeIsActiveEntityCondition = where => {
-  const newWhere = []
-  const length = where.length
-  let i = 0
-
-  while (i < length) {
-    if (_isActiveEntity(where[i])) {
-      i = i + 3
-    } else if (where[i] === 'and' && _isActiveEntity(where[i + 1])) {
-      i = i + 4
-    } else if (where[i].xpr) {
-      if (where[i].xpr.length) {
-        newWhere.push({ xpr: _removeIsActiveEntityCondition(where[i].xpr) })
-      }
-      i++
-    } else {
-      newWhere.push(where[i])
-      i++
-    }
-  }
-
-  if (newWhere[0] === 'and' || newWhere[0] === 'or') {
-    newWhere.splice(0, 1)
-  }
-
-  return newWhere
-}
-
-const _isKeyValue = (i, keys, where) => {
-  if (!where[i].ref || !keys.includes(where[i].ref[0])) {
-    return false
-  }
-
-  return where[i + 1] === '=' && 'val' in where[i + 2]
-}
-
-const deleteCondition = (index, whereCondition, isXpr = false) => {
-  index = _removeMultipleBrackets(index, whereCondition, isXpr)
-  const spliceArgs = _calculateSpliceArgs(index, whereCondition, isXpr)
-  whereCondition.splice(spliceArgs.index, spliceArgs.count)
-  return spliceArgs.index
-}
-
-const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
-  let index = -1
-  for (let i = 0; i < whereCondition.length; i++) {
-    const entry = whereCondition[i]
-    if (entry.xpr) {
-      const result = readAndDeleteKeywords(keywords, entry.xpr, toDelete)
-      if (result) {
-        if (entry.xpr.length === 0) {
-          deleteCondition(i, whereCondition, true)
-        }
-        return result
-      }
-    } else if (entry.ref) {
-      const refLastIndex = entry.ref.length - 1
-
-      if (keywords.length === 1) {
-        if (entry.ref[refLastIndex] === keywords[0]) {
-          index = i
-          break
-        }
-      }
-
-      if (keywords.length === 2 && entry.ref.length >= 2) {
-        if (entry.ref[refLastIndex - 1] === keywords[0] && entry.ref[refLastIndex] === keywords[1]) {
-          index = i
-          break
-        }
-      }
-    }
-  }
-
-  if (index === -1) {
-    return
-  }
-
-  const result = {
-    op: whereCondition[index + 1],
-    value: whereCondition[index + 2]
-  }
-
-  if (toDelete) {
-    deleteCondition(index, whereCondition)
-  }
-
-  return result
-}
-
-const removeIsActiveEntityRecursively = where => {
-  for (const entry of where) {
-    if (entry.xpr) {
-      entry.xpr = removeIsActiveEntityRecursively(entry.xpr)
-      continue
-    }
-
-    if (entry.SELECT && entry.SELECT.where && entry.SELECT.from.ref && !entry.SELECT.from.ref[0].endsWith('_drafts')) {
-      entry.SELECT.where = removeIsActiveEntityRecursively(entry.SELECT.where)
-
-      if (entry.SELECT.where.length === 0) {
-        delete entry.SELECT.where
-      }
-    }
-  }
-
-  return _removeIsActiveEntityCondition(where)
-}
-
-const isActiveEntityRequested = where => {
-  if (!where) return true
-
-  let i = 0
-
-  while (where[i]) {
-    if (where[i].xpr) {
-      const isRequested = isActiveEntityRequested(where[i].xpr)
-      if (isRequested) return true
-    }
-    if (
-      where[i].ref &&
-      where[i].ref[where[i].ref.length - 1] === 'IsActiveEntity' &&
-      where[i + 1] === '=' &&
-      'val' in where[i + 2]
-    ) {
-      return where[i + 2].val === 'true' || where[i + 2].val === true
-    }
-    i++
-  }
-
-  return true
-}
-
-const getKeyData = (keys, where) => {
-  if (!where) {
-    return {}
-  }
-
-  const data = {}
-  let i = 0
-
-  while (where[i]) {
-    if (_isKeyValue(i, keys, where)) {
-      data[where[i].ref[0]] = where[i + 2].val
-      i = i + 3
-    } else {
-      i++
-    }
-  }
-
-  return data
-}
-
-const extractKeyConditions = whereCondition => {
-  const result = {
-    keyList: []
-  }
-
-  const newWhere = [...whereCondition]
-  const readKeywords = readAndDeleteKeywords(['IsActiveEntity'], newWhere)
-  result.IsActiveEntity = readKeywords && readKeywords.value && readKeywords.value.val !== false
-  result.keyList = newWhere
-
-  return result
-}
-
-const getKeysCondition = req => {
-  const data = req.data
-  const target = req.target
-  const where = []
-  for (const k in target.keys) {
-    const key = target.keys[k]
-    if (!key.isAssociation && key.name !== 'IsActiveEntity' && data[key.name] != undefined) {
-      if (where.length) where.push('and')
-      where.push({ ref: [key.name] }, '=', { val: data[key.name] })
-    }
-  }
-  return where
-}
-
-const getLockWhere = (where, columnsMap) => {
-  if (columnsMap.size === 0) return where
-  const whereKeys = Object.keys(where)
-  const lockWhere = {}
-
-  whereKeys.forEach(key => {
-    const mappedKey = columnsMap.get(key)
-    const lockKey = mappedKey ? mappedKey.ref[0] : key
-    lockWhere[lockKey] = where[key]
-  })
-
-  return lockWhere
-}
-
-module.exports = {
-  deleteCondition,
-  readAndDeleteKeywords,
-  removeIsActiveEntityRecursively,
-  isActiveEntityRequested,
-  getKeyData,
-  extractKeyConditions,
-  getKeysCondition,
-  getLockWhere
-}

package/libx/_runtime/index.js

@@ -1,22 +0,0 @@
-module.exports = {
-  to: {
-    /** @type {import('./cds-services/adapter/odata-v4/to')} */
-    get odata_v4() {
-      return this._odatav4 || (this._odatav4 = require('./cds-services/adapter/odata-v4/to'))
-    },
-
-    get rest() {
-      return this._rest || (this._rest = require('../rest'))
-    }
-  },
-
-  /** @type {import('./auth')} */
-  get auth() {
-    return this._auth || (this._auth = require('./auth'))
-  },
-
-  /** @type {import('./common/perf')} */
-  get perf() {
-    return this._perf || (this._perf = require('./common/perf'))
-  }
-}

package/libx/odata/utils/handler.js

@@ -1,120 +0,0 @@
-const cds = require('../../_runtime/cds')
-const { SELECT } = cds.ql
-
-const { DRAFT_COLUMNS_MAP } = require('../../_runtime/common/constants/draft')
-
-const _keysOf = (row, target) => {
-  const keyElements = Object.values(target.keys || {}).filter(v => !v.virtual)
-  // > singleton
-  if (!keyElements.length) return
-  const keys = {}
-  for (const key of keyElements) {
-    if (key._isAssociationStrict) continue
-    if (row[key.name] === undefined) continue // key is not in data, so ignore it
-    keys[key.name] = key.elements ? { val: JSON.stringify(row[key.name]) } : row[key.name]
-  }
-  return keys
-}
-
-const getSimpleSelectCQN = (target, data, columns, subject) => {
-  const keys = _keysOf(data, target)
-  // don't use `ql.where()` to get `where` in `from` for location header
-  let cqn
-  // reflect request path in read after write
-  if (subject?.ref.length > 1) {
-    cqn = SELECT.one(subject)
-    if (keys) cqn.where(keys)
-  } else {
-    cqn = keys ? SELECT.one(target, keys) : /* singleton */ SELECT.one(target)
-  }
-
-  if (columns) {
-    cqn.columns(...columns)
-  }
-
-  if (target.query && target.query.SELECT && target.query.SELECT.orderBy) {
-    cqn.SELECT.orderBy = target.query.SELECT.orderBy
-  }
-
-  return cqn
-}
-
-const _mergeExpandCQNs = cqns => {
-  const cols = cqns[0].SELECT.columns
-  for (const cqn of cqns.slice(1)) {
-    for (const col of cqn.SELECT.columns) {
-      if (!col.expand) continue
-      const idx = cols.findIndex(ele => {
-        if (!col.ref) return
-        if (ele.ref) return ele.ref[0] === col.ref[0]
-        if (ele.as) return ele.as === col.ref[0]
-      })
-      if (idx === -1) {
-        cols.push(col)
-      } else {
-        const colExists = cols[idx]
-        if (colExists.as && colExists.val === null) {
-          cols[idx] = col
-          continue
-        }
-        if (col.as && col.val === null) continue
-        const mergedExpandCQN = _mergeExpandCQNs([
-          { SELECT: { columns: colExists.expand } },
-          { SELECT: { columns: col.expand } }
-        ])
-        colExists.expand = mergedExpandCQN.SELECT.columns
-      }
-    }
-  }
-  return cqns[0]
-}
-
-const _getExpandColumn = (data, element) => {
-  const key = element.name
-  if (!(key in data)) return
-  data = data[key]
-  if ((Array.isArray(data) && data.length === 0) || data == null) {
-    // performance tweak, keep in mind it is only for compositions
-    return { val: null, as: key }
-  }
-  const cqn = Array.isArray(data)
-    ? _mergeExpandCQNs(data.map(data => getDeepSelect({ target: element._target, data })))
-    : getDeepSelect({ target: element._target, data })
-  return { ref: [key], expand: cqn.SELECT.columns }
-}
-
-const _getColumns = (target, data, prefix = []) => {
-  const columns = []
-  for (const each in target.elements) {
-    if (target.elements[each]['@cds.api.ignore']) continue
-    if (each in DRAFT_COLUMNS_MAP) continue
-    if (!cds.env.features.stream_compat && target.elements[each].type === 'cds.LargeBinary') continue
-    const element = target.elements[each]
-    if (element.elements && data[each]) {
-      prefix.push(element.name)
-      columns.push(..._getColumns(element, data[each], prefix))
-      prefix.pop()
-    } else if (element.isComposition && !prefix.length) {
-      const col = _getExpandColumn(data, element, prefix)
-      if (col) columns.push(col)
-    } else if (!element.isAssociation) {
-      columns.push({ ref: [...prefix, each] })
-    }
-  }
-  return columns
-}
-
-/*
- * recursively builds a select cqn for deep read after write
- * (depth determined by req.data)
- */
-const getDeepSelect = req => {
-  let { target, data, subject } = req
-  const columns = _getColumns(target, data)
-  return getSimpleSelectCQN(target, data, columns, subject)
-}
-
-module.exports = {
-  getDeepSelect,
-  getSimpleSelectCQN
-}