@sap/cds 8.9.3 → 9.0.2

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

@@ -1,174 +0,0 @@
-module.exports = {
-  SET: {
-    op: 'union',
-    all: true,
-    args: [
-      {
-        SELECT: {
-          from: {
-            join: 'inner',
-            args: [
-              {
-                ref: ['%%DRAFT%%']
-              },
-              {
-                ref: ['DRAFT.DraftAdministrativeData'],
-                as: 'filterAdmin'
-              }
-            ],
-            on: [
-              {
-                ref: ['%%DRAFT%%', 'DraftAdministrativeData_DraftUUID']
-              },
-              '=',
-              {
-                ref: ['filterAdmin', 'DraftUUID']
-              }
-            ]
-          },
-          where: [
-            {
-              ref: ['filterAdmin', 'InProcessByUser']
-            },
-            '=',
-            {
-              val: '%%USER%%'
-            }
-          ],
-          columns: [
-            '%%DRAFT_COLUMNS%%',
-            {
-              ref: ['IsActiveEntity'],
-              cast: {
-                type: 'cds.Boolean'
-              }
-            },
-            {
-              ref: ['HasActiveEntity'],
-              cast: {
-                type: 'cds.Boolean'
-              }
-            },
-            {
-              ref: ['HasDraftEntity'],
-              cast: {
-                type: 'cds.Boolean'
-              }
-            },
-            {
-              ref: ['DraftAdministrativeData_DraftUUID']
-            }
-          ]
-        }
-      },
-      {
-        SELECT: {
-          from: {
-            ref: ['%%ACTIVE%%']
-          },
-          columns: [
-            '%%ACTIVE_COLUMNS%%',
-            {
-              val: true,
-              as: 'IsActiveEntity',
-              cast: {
-                type: 'cds.Boolean'
-              }
-            },
-            {
-              val: false,
-              as: 'HasActiveEntity',
-              cast: {
-                type: 'cds.Boolean'
-              }
-            },
-            {
-              xpr: [
-                'case',
-                'when',
-                {
-                  SELECT: {
-                    from: {
-                      ref: ['%%DRAFT%%']
-                    },
-                    columns: [
-                      {
-                        val: 1
-                      }
-                    ],
-                    where: [{ xpr: ['%%KEYS%%'] }]
-                  },
-                  as: 'HasDraftEntity',
-                  cast: {
-                    type: 'cds.Boolean'
-                  }
-                },
-                'IS NOT NULL',
-                'then',
-                'true',
-                'else',
-                'false',
-                'end'
-              ],
-              as: 'HasDraftEntity',
-              cast: {
-                type: 'cds.Boolean'
-              }
-            },
-            {
-              SELECT: {
-                from: {
-                  ref: ['%%DRAFT%%']
-                },
-                columns: [
-                  {
-                    ref: ['DraftAdministrativeData_DraftUUID']
-                  }
-                ],
-                where: [{ xpr: ['%%KEYS%%'] }]
-              }
-            }
-          ],
-          where: [
-            'not exists',
-            {
-              SELECT: {
-                from: {
-                  join: 'inner',
-                  args: [
-                    {
-                      ref: ['%%DRAFT%%']
-                    },
-                    {
-                      ref: ['DRAFT.DraftAdministrativeData'],
-                      as: 'filterAdmin'
-                    }
-                  ],
-                  on: [
-                    {
-                      ref: ['%%DRAFT%%', 'DraftAdministrativeData_DraftUUID']
-                    },
-                    '=',
-                    {
-                      ref: ['filterAdmin', 'DraftUUID']
-                    }
-                  ]
-                },
-                columns: [
-                  {
-                    val: 1
-                  }
-                ],
-                where: [
-                  { xpr: [{ ref: ['filterAdmin', 'InProcessByUser'] }, '=', { val: '%%USER%%' }] },
-                  'and',
-                  { xpr: ['%%KEYS%%'] }
-                ]
-              }
-            }
-          ]
-        }
-      }
-    ]
-  }
-}

package/libx/_runtime/db/Service.js

@@ -1,93 +0,0 @@
-const cds = require('../cds')
-
-/*
- * generic queries
- */
-const queries = require('./query')
-
-/*
- * generic handlers
- */
-const generic = require('./generic')
-
-class DatabaseService extends cds.Service {
-  constructor(...args) {
-    super(...args)
-
-    // REVISIT: official db api
-    this._queries = queries
-
-    // REVISIT: official db api
-    for (const each in generic) {
-      this[`_${each}`] = generic[each]
-    }
-
-    // REVISIT: how to generic handler registration?
-  }
-
-  /** Database services don't support custom-defined operations */
-  get operations() {
-    return []
-  }
-
-  /** Database services don't support custom-defined events */
-  get events() {
-    return []
-  }
-
-  /*
-   * tx
-   */
-  async begin() {
-    const tx = this.context ? this : this.tx()
-    tx.dbc = await tx.acquire(tx.context)
-    try {
-      await tx.send('BEGIN')
-    } catch (e) {
-      tx.release(tx.dbc)
-      throw e
-    }
-    return tx
-  }
-
-  async commit() {
-    // only release on successful commit as otherwise released on rollback
-    await this.send('COMMIT')
-    this.release(this.dbc)
-  }
-
-  async rollback() {
-    if (this.dbc) {
-      try {
-        await this.send('ROLLBACK')
-      } finally {
-        this.release(this.dbc)
-      }
-    }
-  }
-
-  /*
-   * streaming
-   */
-  _runStream(streamQuery, result) {
-    this.run(streamQuery).then(stream => {
-      if (cds.env.features.stream_compat) {
-        if (!stream || !stream.value) {
-          result.push(null)
-        } else {
-          stream.value.pipe(result)
-        }
-      } else {
-        const col = streamQuery.SELECT.columns[0].ref[0]
-        if (!stream || !stream[col]) {
-          result.push(null)
-        } else {
-          stream[col].pipe(result)
-        }
-      }
-    })
-  }
-}
-
-DatabaseService.prototype.isDatabaseService = true
-module.exports = DatabaseService

package/libx/_runtime/db/data-conversion/post-processing.js

@@ -1,175 +0,0 @@
-const { getEntityNameFromCQN, traverseFroms } = require('../../common/utils/entityFromCqn')
-const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
-
-const _getCastFunction = ({ type }) => {
-  switch (type) {
-    case 'cds.Boolean':
-      return Boolean
-    case 'cds.Integer':
-    case 'cds.UInt8':
-    case 'cds.Int16':
-    case 'cds.Int32':
-      return Number
-    default:
-      return String
-  }
-}
-
-const _structElement = (definition, structPath) => {
-  if (definition.elements) {
-    return _structElement(definition.elements[structPath[0]], structPath.slice(1))
-  }
-
-  return definition
-}
-
-const _getNestedElement = (entity, key) => {
-  if (entity.elements[key]) return entity.elements[key]
-
-  const structPath = entity._flat2struct[key]
-  if (!structPath) return
-
-  return _structElement(entity, structPath)
-}
-
-const _addConverter = (mapper, name, converter) => {
-  if (mapper.has(name)) {
-    const oldConverter = mapper.get(name)
-    mapper.set(name, (val, key, row, unaliasedKey) => {
-      oldConverter(val, key, row, unaliasedKey)
-      converter(row[unaliasedKey || key], key, row, unaliasedKey)
-    })
-  } else {
-    mapper.set(name, converter)
-  }
-}
-
-/**
- * Get a map of to be converted elements and their conversion functions.
- *
- * @param {Map} conversionMap - Mapping instructions for data conversions based on CDS data types
- * @param {object} csn - Reflected CSN
- * @param {object} cqn - CQN that is used to query the DB.
- * @returns {Map<any, any>}
- * @private
- */
-const _getMapperForListedElements = (conversionMap, csn, cqn) => {
-  const mapper = new Map()
-
-  const alias2entity = {}
-  if (cqn.SELECT.from.args) {
-    for (const each of cqn.SELECT.from.args) {
-      const { entityName, alias } = getEntityNameFromCQN(each)
-      let as = each.as || alias
-      if (as) as = ensureNoDraftsSuffix(as) // > in comp2one, the alias gets suffixed with "_drafts"
-      alias2entity[as] =
-        csn.definitions[ensureNoDraftsSuffix(entityName)] || csn.definitions[entityName.replace(/\.drafts$/, '')]
-    }
-    // additionally, for deeply nested args, find pairs of single-element ref + as and build alias to entity mapping
-    const ref2as = []
-    traverseFroms(cqn.SELECT.from, from => ref2as.push({ ref: from.ref, as: from.as }))
-    for (const each of ref2as) {
-      alias2entity[each.as] =
-        csn.definitions[ensureNoDraftsSuffix(each.ref[0])] || csn.definitions[each.ref[0].replace(/\.drafts$/, '')]
-    }
-  } else {
-    const { entityName } = getEntityNameFromCQN(cqn)
-    alias2entity[0] = csn.definitions[ensureNoDraftsSuffix(entityName)]
-  }
-
-  for (const col of cqn.SELECT.columns) {
-    if (col.cast) {
-      const name = col.as ? col.as : col.ref[col.ref.length - 1]
-      _addConverter(mapper, name, (val, key, row, unaliasedKey) => {
-        row[unaliasedKey || key] = val === null ? null : _getCastFunction(col.cast)(val)
-      })
-      continue
-    }
-    if (col.ref) {
-      const name = col.ref[col.ref.length - 1]
-
-      const entity =
-        col.ref.length > 1
-          ? alias2entity[col.ref[0]] || alias2entity[0]
-          : alias2entity[0] || alias2entity[getEntityNameFromCQN(cqn).alias]
-      if (!entity) {
-        // REVISIT: should not be necessary, but HasActiveEntity is not always prefixed with alias
-        if (col.ref.length === 1 && col.ref[0] === 'HasActiveEntity')
-          _addConverter(mapper, col.as ? col.as : name, (val, key, row, unaliasedKey) => {
-            row[unaliasedKey || key] = conversionMap.get('cds.Boolean')(val)
-          })
-        continue
-      }
-
-      const element = _getNestedElement(entity, name)
-      if (!element) continue
-
-      // REVISIT: _type is undefined for cds.hana.CLOB etc.
-      const type = element._type || element.type
-      if (conversionMap.has(type)) {
-        _addConverter(mapper, col.as ? col.as : name, (val, key, row, unaliasedKey) => {
-          row[unaliasedKey || key] = conversionMap.get(type)(val)
-        })
-      } else if (element.items) {
-        _addConverter(mapper, col.as ? col.as : name, (val, key, row, unaliasedKey) => {
-          const effectiveKey = unaliasedKey || key
-          row[effectiveKey] = JSON.parse(val)
-        }) // > arrayed elements
-      }
-    }
-  }
-
-  return mapper
-}
-
-/**
- * Based on CSN and CQN get a map on how to map the result.
- *
- * @param {Map} conversionMap - Mapping instructions for data conversions based on CDS data types
- * @param {object} csn - Reflected CSN
- * @param {object} cqn - CQN that is used to query the DB.
- * @returns {Map<any, any>}
- * @private
- */
-const getPostProcessMapper = (conversionMap, csn, cqn) => {
-  // No mapper defined or irrelevant as no CSN, CQN or READ request
-  if (!csn || !cqn || !Object.prototype.hasOwnProperty.call(cqn, 'SELECT')) {
-    return new Map()
-  }
-
-  return cqn.SELECT.columns ? _getMapperForListedElements(conversionMap, csn, cqn) : new Map()
-}
-
-const _processRow = (mapper, row) => {
-  if (!row) return
-  for (const [columnName, converter] of mapper.entries()) {
-    converter(row[columnName], columnName, row)
-  }
-}
-
-/**
- * Post process the result as given by the db driver.
- *
- * @param {*} result - The result as returned by the db driver.
- * @param {Map} mapper - Instructions, how to transform.
- * @param {Map} propertyMapper - Instructions, how to rename properties.
- * @param {Map} objStructMapper - Instructions, how to rename properties.
- * @returns {*}
- * @private
- */
-const postProcess = (result, mapper = new Map()) => {
-  if (mapper.size === 0) return result
-
-  if (Array.isArray(result)) for (const each of result) _processRow(mapper, each)
-  else _processRow(mapper, result)
-
-  return result
-}
-
-/*
- * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
- */
-module.exports = {
-  getPostProcessMapper,
-  postProcess
-}

package/libx/_runtime/db/expand/expand-v2.js

@@ -1,147 +0,0 @@
-const cds = require('../../cds')
-const getColumns = require('../utils/columns')
-
-const _identifierForRow = (row, prefix, keys) => {
-  return keys.map(k => row[`${prefix}${k}`]).join(',')
-}
-
-const _removeParentKeysFromRow = (row, prefix, keys) => {
-  for (const k of keys) {
-    delete row[`${prefix}${k}`]
-  }
-}
-
-const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth, options) => {
-  for (const nav in entity._associations) {
-    const navigation = entity._associations[nav]
-    if (options.onlyCompositions && navigation._isAssociationStrict) continue
-
-    // do not expand backlinks
-    if (navigation._isBacklink) continue
-
-    const childAlias = 'child'
-    const parentAlias = 'parent'
-
-    const cqnQuery = SELECT.from(`${navigation.target} as ${childAlias}`)
-      .join(`${entity.name} as ${parentAlias}`)
-      .on(entity._relations[navigation.name].join(childAlias, parentAlias))
-
-    // set alias for expanded columns already
-    const childColumns = getColumns(navigation._target, { _4db: true, onlyKeys: options.onlyKeys }).map(c => ({
-      ref: [childAlias, c.name]
-    }))
-    const parentKeys = Object.keys(entity.keys).filter(k => !entity.keys[k].isAssociation)
-    // mark parent key with prefix in alias
-    const parentKeysWithAlias = parentKeys.map(pk => ({ ref: [parentAlias, pk], as: `$$pk_${pk}` }))
-    cqnQuery.columns(...childColumns, ...parentKeysWithAlias)
-
-    // add tuple comparison for where clause
-    cqnQuery.where([
-      { list: parentKeys.map(pk => ({ ref: [parentAlias, pk] })) },
-      'in',
-      { list: previousResult.map(row => ({ list: parentKeys.map(pk => ({ val: row[pk] })) })) }
-    ])
-
-    // sort by primary keys of parent, required in future
-    cqnQuery.orderBy(parentKeys.map(pk => ({ ref: [parentAlias, pk] })))
-
-    const result = await cds.db.run(cqnQuery)
-
-    // TODO: Is there a more efficient/stable way to handle compound keys?
-    const map = new Map()
-    for (const row of result) {
-      const identifier = _identifierForRow(row, '$$pk_', parentKeys)
-      _removeParentKeysFromRow(row, '$$pk_', parentKeys)
-      if (map.has(identifier)) {
-        map.get(identifier).push(row)
-      } else {
-        map.set(identifier, [row])
-      }
-    }
-
-    // link previous result with current result
-    previousResult.forEach(row => {
-      const identifier = _identifierForRow(row, '', parentKeys)
-      if (map.has(identifier)) {
-        const entry = map.get(identifier)
-        row[nav] = navigation.is2one ? entry[0] : entry
-      } else {
-        row[nav] = navigation.is2one ? null : []
-      }
-    })
-
-    // expand next level if needed
-    if (depth - 1 !== 0 && result.length && navigation._target._associations) {
-      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1, options)
-    }
-  }
-
-  return previousResult
-}
-
-const _fkForOnCOnd = (onCond, requiredFks) => {
-  for (const ele of onCond) {
-    if (ele.xpr) {
-      _fkForOnCOnd(ele.xpr, requiredFks)
-    }
-
-    if (ele.ref && ele.ref[0] === 'parent') {
-      requiredFks.add(ele.ref.slice(1).join('_'))
-    }
-  }
-}
-
-const _foreignKeysOfTopLevelNavs = (entity, options) => {
-  const requiredFks = new Set()
-  for (const nav in entity._associations) {
-    if (options.onlyCompositions && entity._associations[nav]._isAssociationStrict) continue
-    const onCond = entity._relations[nav].join('child', 'parent')
-    _fkForOnCOnd(onCond, requiredFks)
-  }
-  return [...requiredFks]
-}
-
-const _addForeignKeys = (columns, entity, options) => {
-  const fks = _foreignKeysOfTopLevelNavs(entity, options)
-  fks.forEach(fk => {
-    if (!columns.some(c => c.ref[0] === fk)) {
-      columns.push({ ref: [fk] })
-    }
-  })
-}
-
-/**
- * 1. Creates flattened SQL statements for each expand layer
- * 2. Mixes in foreign keys if needed
- * 3. Merges results
- * 4. Cleans result if needed
- *
- * @returns object
- */
-const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSelectCQN) => {
-  const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand[0] === 'string')
-  const options = Object.assign({ onlyKeys: false, onlyCompositions: false }, expandColumn._options)
-  // remove expand columns from query without modifying
-  const topLevelSelect = query.clone().columns(query.SELECT.columns.filter(c => !c.expand))
-
-  const entity = model.definitions[topLevelSelect.SELECT.from.ref[0]]
-
-  // ensure foreign keys are selected if needed
-  _addForeignKeys(topLevelSelect.SELECT.columns, entity, options)
-
-  const result = await executeSelectCQN(model, dbc, topLevelSelect, user, locale, txTimestamp)
-
-  if (!result || (Array.isArray(result) && !result.length)) {
-    return result
-  }
-
-  // _associations contains compositions and associations
-  if (entity._associations) {
-    const depth = expandColumn.expand[0] === '**' ? -1 : Number(expandColumn.expand[0].replace('*', ''))
-    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth, options)
-  }
-
-  return result
-}
-
-module.exports = expandV2