@sap/cds 8.9.3 → 9.0.2

package/libx/_runtime/common/composition/insert.js

@@ -1,108 +0,0 @@
-const cds = require('../../cds')
-
-const { getCompositionTree } = require('./tree')
-const ctUtils = require('./utils')
-
-const { ensureNoDraftsSuffix } = require('../utils/draft')
-const { deepCopy } = require('../utils/copy')
-
-/*
- * own utils
- */
-
-function _hasCompOrAssoc(entity, k) {
-  // TODO once REST also uses same logic as odata structured check if we can omit 'entity.elements[k] &&'
-  return entity.elements[k] && (entity.elements[k].is2one || entity.elements[k].is2many)
-}
-
-const _addSubDeepInsertCQN = (model, compositionTree, data, cqns, draft) => {
-  compositionTree.compositionElements.forEach(element => {
-    if (element.skipPersistence) return
-
-    // element source must be changed in comp tree
-    const subEntity = model.definitions[element.source]
-    const into = ctUtils.addDraftSuffix(draft, subEntity.name)
-    const insertCQN = { INSERT: { into: into, entries: [] } }
-    const subData = data.reduce((result, entry) => {
-      if (element.name in entry) {
-        const elementValue = ctUtils.val(entry[element.name])
-        if (elementValue != null) {
-          // remove empty entries
-          const subData = ctUtils.array(elementValue).filter(ele => Object.keys(ele).length > 0)
-          if (subData.length > 0) {
-            // REVISIT: this can make problems
-            const entries = insertCQN.INSERT.entries
-            for (const data of ctUtils.cleanDeepData(subEntity, subData)) entries.push(data)
-            for (const data of subData) result.push(data)
-          }
-        }
-      }
-
-      return result
-    }, [])
-
-    if (insertCQN.INSERT.entries.length > 0) {
-      cqns.push(insertCQN)
-    }
-
-    if (subData.length > 0) {
-      _addSubDeepInsertCQN(model, element, subData, cqns, draft)
-    }
-  })
-
-  return cqns
-}
-
-/*
- * exports
- */
-
-const _entityFromINSERT = (model, INSERT) => {
-  if (INSERT && INSERT.into) {
-    const into = (INSERT.into.ref && INSERT.into.ref[0]) || INSERT.into.name || INSERT.into
-    const entityName = ensureNoDraftsSuffix(into)
-    return model.definitions[entityName]
-  }
-}
-
-const hasDeepInsert = (model, cqn) => {
-  if (cqn.INSERT.entries) {
-    const entity = _entityFromINSERT(model, cqn.INSERT)
-    if (entity) {
-      return !!cqn.INSERT.entries.find(entry => {
-        return !!Object.keys(entry || {}).find(k => {
-          return _hasCompOrAssoc(entity, k)
-        })
-      })
-    }
-  }
-  return false
-}
-
-const getDeepInsertCQNs = (model, cqn) => {
-  const into = (cqn.INSERT.into.ref && cqn.INSERT.into.ref[0]) || cqn.INSERT.into.name || cqn.INSERT.into
-  const entityName = ensureNoDraftsSuffix(into)
-  const draft = entityName !== into || into.endsWith('.drafts') //lean draft
-  const dataEntries = cqn.INSERT.entries ? deepCopy(cqn.INSERT.entries) : []
-  const entity = model.definitions[entityName]
-  const compositionTree = getCompositionTree({
-    definitions: model.definitions,
-    rootEntityName: entityName,
-    resolveViews: !draft,
-    service: cds.db
-  })
-
-  const flattenedCqn = { INSERT: Object.assign({}, cqn.INSERT) }
-  flattenedCqn.INSERT.entries = []
-
-  dataEntries.forEach(dataEntry =>
-    flattenedCqn.INSERT.entries.push(ctUtils.cleanDeepData(entity, Object.assign({}, dataEntry)))
-  )
-
-  return [flattenedCqn, ..._addSubDeepInsertCQN(model, compositionTree, dataEntries, [], draft)]
-}
-
-module.exports = {
-  hasDeepInsert,
-  getDeepInsertCQNs
-}

package/libx/_runtime/common/composition/tree.js

@@ -1,275 +0,0 @@
-const cds = require('../../cds')
-
-const { prefixForStruct } = require('../../common/utils/csn')
-
-/*
- * own utils
- */
-
-const _foreignKeysToLinks = (element, inverse) =>
-  element._foreignKeys.map(e => {
-    e = inverse
-      ? {
-          childElement: e.parentElement,
-          parentElement: e.childElement,
-          childFieldValue: e.parentFieldValue,
-          parentFieldValue: e.childFieldValue
-        }
-      : e
-    const link = {}
-    if (e.parentElement) link.entityKey = prefixForStruct(e.parentElement) + e.parentElement.name
-    if (e.childElement) link.targetKey = prefixForStruct(e.childElement) + e.childElement.name
-    if (e.parentFieldValue !== undefined) link.entityVal = e.parentFieldValue
-    if (e.childFieldValue !== undefined) link.targetVal = e.childFieldValue
-    return link
-  })
-
-const _resolvedElement = (element, service) => {
-  if (!element.target) return element
-  // skip forbidden view check if association to view with foreign key in target
-  const skipForbiddenViewCheck = element._isAssociationStrict
-  const { target, mapping } = cds.ql.resolve.transitions4db(
-    { target: element._target },
-    cds.db.tx(service),
-    skipForbiddenViewCheck
-  ) // must use db service
-  const newElement = { target: target.name, _target: target }
-  Object.setPrototypeOf(newElement, element)
-  if (element.on) {
-    newElement.on = element.on.map(onEl => {
-      if (!onEl.ref || onEl.ref[0] !== element.name) return onEl
-      const mapped = mapping.get(onEl.ref[1])
-      if (!mapped || !mapped.ref) return onEl
-      const newRef = [onEl.ref[0], mapped.ref[0]]
-      return { ...onEl, ...{ ref: newRef } }
-    })
-  }
-  return newElement
-}
-
-const _navigationExistsInCompositionMap = (element, compositionMap) =>
-  compositionMap.has(element.target) && element.isComposition
-
-const _isUnManaged = element => element.on && !element._isSelfManaged
-
-const _isNonRecursiveNavigation = (element, rootEntityName) =>
-  rootEntityName !== element.target && element.isComposition
-
-const _skipPersistence = (element, definitions) => definitions[element.target]._hasPersistenceSkip
-
-const _createSubElement = (element, definitions) => {
-  const subObject = { name: element.name, customBackLinks: [], links: [], backLinks: [] }
-  if (_skipPersistence(element, definitions)) {
-    subObject.skipPersistence = true
-  }
-  return subObject
-}
-
-const _getCompositionTreeRec = ({
-  rootEntityName,
-  definitions,
-  compositionMap,
-  compositionTree,
-  entityName,
-  parentEntityName,
-  resolveViews,
-  service
-}) => {
-  compositionMap.set(parentEntityName, compositionTree)
-  compositionTree.source = parentEntityName
-  if (parentEntityName !== rootEntityName) {
-    compositionTree.target = entityName
-  }
-  compositionTree.compositionElements = []
-  compositionTree.backLinks = compositionTree.backLinks || []
-  compositionTree.customBackLinks = compositionTree.customBackLinks || []
-
-  const parentEntity = definitions[parentEntityName]
-
-  for (const elementName in parentEntity.elements) {
-    const unresolvedEl = parentEntity.elements[elementName]
-    const element = resolveViews ? _resolvedElement(unresolvedEl, service) : unresolvedEl
-    if (!element.isAssociation) continue
-    if (_navigationExistsInCompositionMap(element, compositionMap)) {
-      const compositionElement = Object.assign({}, compositionMap.get(element.target), {
-        name: element.name,
-        target: parentEntityName,
-        links: [],
-        backLinks: [],
-        customBackLinks: []
-      })
-      if (!element._isSelfManaged) {
-        const backLinks = _foreignKeysToLinks(element, true) || []
-        if (element.is2many) {
-          compositionElement.customBackLinks.push(...backLinks)
-        } else {
-          compositionElement.backLinks.push(...backLinks)
-        }
-      } else {
-        const targetEntity = definitions[element.target]
-        for (const backLinkName in targetEntity.elements) {
-          const _backLink = targetEntity.elements[backLinkName]
-          if (!_backLink._isAssociationStrict) continue
-          if (
-            _backLink._isCompositionBacklink &&
-            _backLink.target === compositionElement.target &&
-            _backLink._anchor.name === element.name
-          ) {
-            const backLinks = _foreignKeysToLinks(_backLink) || []
-            if (_isUnManaged(element)) {
-              compositionElement.customBackLinks.push(...backLinks)
-            } else {
-              compositionElement.backLinks.push(...backLinks)
-            }
-          }
-        }
-      }
-      compositionTree.compositionElements.push(compositionElement)
-    } else if (_isNonRecursiveNavigation(element, rootEntityName)) {
-      const subObject = _createSubElement(element, definitions)
-      if (!element._isSelfManaged) {
-        const backLinks = _foreignKeysToLinks(element, true) || []
-        if (element.is2many) {
-          subObject.customBackLinks.push(...backLinks)
-        } else {
-          subObject.is2one = true
-          backLinks.forEach(b => (b.for2one = true))
-          subObject.backLinks.push(...backLinks)
-        }
-      }
-      compositionTree.compositionElements.push(subObject)
-      _getCompositionTreeRec({
-        rootEntityName,
-        definitions,
-        compositionMap,
-        compositionTree: subObject,
-        entityName: parentEntityName,
-        parentEntityName: element.target,
-        service
-      })
-    } else if (
-      element._isAssociationStrict &&
-      element._isCompositionBacklink &&
-      element.target === compositionTree.target &&
-      compositionMap.has(element.target)
-    ) {
-      const backLinks = _foreignKeysToLinks(element) || []
-      if (_isUnManaged(element)) {
-        compositionTree.customBackLinks.push(...backLinks)
-      } else {
-        compositionTree.backLinks.push(...backLinks)
-      }
-    }
-  }
-}
-
-const _resolvedEntityName = (entityName, definitions) => {
-  const target = definitions[entityName]
-  if (!target) return entityName
-  const resolved = cds.ql.resolve.table(target)
-  return resolved.name
-}
-
-const _removeLocalizedTextsFromDraftTree = (compositionTree, definitions, checkedEntities = new Set()) => {
-  for (const e of compositionTree.compositionElements) {
-    if (checkedEntities.has(e.source)) {
-      return
-    }
-
-    const target = definitions[e.target]
-    if (e.name === 'texts' && target.elements.localized && !target['@fiori.draft.enabled']) {
-      compositionTree.compositionElements.splice(compositionTree.compositionElements.indexOf(e), 1)
-    } else {
-      checkedEntities.add(e.source)
-      _removeLocalizedTextsFromDraftTree(e, definitions, checkedEntities)
-    }
-  }
-}
-
-const _getCompositionTree = ({ definitions, rootEntityName, resolveViews = false, service }) => {
-  const rootName = resolveViews ? _resolvedEntityName(rootEntityName, definitions) : rootEntityName
-
-  const compositionTree = {}
-  _getCompositionTreeRec({
-    rootEntityName: rootName,
-    definitions,
-    compositionMap: new Map(),
-    compositionTree,
-    entityName: rootName,
-    parentEntityName: rootName,
-    resolveViews,
-    service
-  })
-
-  if (definitions[rootEntityName]._isDraftEnabled) {
-    _removeLocalizedTextsFromDraftTree(compositionTree, definitions)
-  }
-
-  return compositionTree
-}
-
-const _cacheCompositionParentsOfOne = ({ definitions }) => {
-  for (const parentName in definitions) {
-    const parent = definitions[parentName]
-    if (!parent.kind === 'entity' || !parent.elements) continue
-    for (const elementName in parent.elements) {
-      const element = parent.elements[elementName]
-      if (element.isComposition && element.is2one && !element._isSelfManaged) {
-        const targetName = element.target
-        const target = definitions[targetName]
-        if (!target) continue
-        const parentMap = (target.own('__oneCompositionParents') && target.__oneCompositionParents) || new Map()
-        const binding = parentMap.get(parentName) || {}
-        binding.elements = binding.elements || new Map()
-        const el = _createSubElement(element, definitions)
-        el.target = targetName
-        el.source = parentName
-        el.links = _foreignKeysToLinks(element)
-        binding.elements.set(element.name, el)
-        parentMap.set(parentName, binding)
-        target.set('__oneCompositionParents', parentMap)
-      }
-    }
-  }
-}
-
-const _memoizeGetCompositionTree = fn => {
-  const cache = new Map()
-  return ({ definitions, rootEntityName, resolveViews = false, service }) => {
-    const key = rootEntityName
-
-    // use ApplicationService as cache key for extensibility
-    // REVISIT: context._tx is not a stable API -> pls do not rely on that
-    const cacheKey = (cds.context && cds.context.tx && Object.getPrototypeOf(cds.context.tx)) || definitions
-
-    const map = cache.get(cacheKey)
-    const cachedResult = map && map.get(key)
-    if (cachedResult) return cachedResult
-    _cacheCompositionParentsOfOne({ definitions })
-    const compTree = fn({ definitions, rootEntityName, resolveViews, service })
-
-    const _map = map || new Map()
-    _map.set(key, compTree)
-    if (!map) cache.set(cacheKey, _map)
-
-    return compTree
-  }
-}
-
-/*
- * exports
- */
-
-/**
- * Provides tree of all compositions. (Cached)
- *
- * @param {object} definitions Definitions of the reflected model
- * @param {string} rootEntityName Name of the root entity
- * @returns {object} tree of all compositions
- * @throws Error if no valid root entity provided
- */
-const getCompositionTree = _memoizeGetCompositionTree(_getCompositionTree)
-
-module.exports = {
-  getCompositionTree
-}