@sap/cds 6.1.3 → 6.2.1

package/libx/_runtime/extensibility/handler/transformWRITE.js

@@ -1,64 +0,0 @@
-const { EXT_BACK_PACK, getTargetWrite, isExtendedEntity } = require('../utils')
-
-const getTemplate = require('../../common/utils/template')
-const templateProcessor = require('../../common/utils/templateProcessor')
-
-const _pick = element => {
-  return element['@cds.extension']
-}
-
-const _processorFn = ({ row, key }) => {
-  if (row[key] === undefined) return
-
-  if (!row[EXT_BACK_PACK]) {
-    row[EXT_BACK_PACK] = '{}'
-  }
-
-  const json = JSON.parse(row[EXT_BACK_PACK])
-  json[key] = row[key]
-  row[EXT_BACK_PACK] = JSON.stringify(json)
-  delete row[key]
-}
-
-function transformExtendedFieldsCREATE(req) {
-  if (!req.query) return // FIXME: the code below expects req.query to be defined
-  if (!req.target) return
-  if (!req.query.INSERT.entries) return // REVISIT: breaks at cds.deploy -> should anyways not kick in during cds.deploy
-
-  const target = getTargetWrite(req.target, this.model)
-  const template = getTemplate('transform-write', this, target, { pick: _pick })
-
-  if (template && template.elements.size > 0) {
-    for (const row of req.query.INSERT.entries) {
-      const args = { processFn: _processorFn, row, template }
-      templateProcessor(args)
-    }
-  }
-}
-
-async function transformExtendedFieldsUPDATE(req) {
-  if (!req.target || !req.query.UPDATE.where) return
-
-  const target = getTargetWrite(req.target, this.model)
-  const template = getTemplate('transform-write', Object.assign(req, { model: this.model }), target, { pick: _pick })
-
-  if (template && template.elements.size > 0) {
-    // In patch case we first should obtain backpack from db.
-    // Patch can be only applied to the root.
-    if (isExtendedEntity(target.name, this.model)) {
-      const current = await SELECT.from(req.query.UPDATE.entity).columns([EXT_BACK_PACK]).where(req.query.UPDATE.where)
-
-      if (current[0]) {
-        req.data[EXT_BACK_PACK] = JSON.stringify(current[0])
-      }
-    }
-
-    const args = { processFn: _processorFn, row: req.data, template }
-    templateProcessor(args)
-  }
-}
-
-module.exports = {
-  transformExtendedFieldsCREATE,
-  transformExtendedFieldsUPDATE
-}

package/libx/_runtime/extensibility/linter/allowlist_checker.js

@@ -1,373 +0,0 @@
-const Checker = require('./checker_base')
-
-const LABELS = {
-  service: 'Service',
-  entity: 'Entity',
-  aspect: 'Aspect',
-  type: 'Type'
-}
-
-const LEGACY_ENTITY_WHITELIST = 'entity-whitelist'
-const LEGACY_SERVICE_WHITELIST = 'service-whitelist'
-const EXTENSION_ALLOWLIST = 'extension-allowlist'
-const NEW_FIELDS = 'new-fields'
-const NEW_ENTITIES = 'new-entities'
-
-class Allowlist {
-  constructor(mtxConfig, fullCsn) {
-    this.allowlist = Allowlist._setupPermissionList(mtxConfig, fullCsn)
-  }
-
-  get all() {
-    return this.allowlist.all
-  }
-
-  get entity() {
-    return this.allowlist.entity
-  }
-
-  get service() {
-    return this.allowlist.service
-  }
-
-  getList(kind) {
-    return this.allowlist[kind]
-  }
-
-  getPermission(kind, name) {
-    function findInList(list, name) {
-      if (list) {
-        const splitName = name.split('.')
-        while (splitName.length > 0) {
-          const nameOrPrefix = splitName.join('.')
-          if (list[nameOrPrefix]) {
-            return list[nameOrPrefix]
-          }
-          splitName.pop()
-        }
-        return list['*'] ? list['*'] : null
-      }
-      return null
-    }
-
-    return findInList(this.allowlist[kind], name) || findInList(this.allowlist['all'], name)
-  }
-
-  isAllowed(kind, name) {
-    return !!this.getPermission(kind, name)
-  }
-
-  static _setupPermissionList(mtxConfig, fullCsn) {
-    // internal structure:
-    // result[name] = { kind, new-fields | new-entities }
-
-    const result = {}
-
-    // create from legacy lists
-    let { entityWhitelist, serviceWhitelist } = Allowlist._getLegacyLists(mtxConfig)
-
-    // create from new lists
-    const allowlistNewFormat = mtxConfig[EXTENSION_ALLOWLIST]
-
-    Allowlist._addLegacyLists(result, serviceWhitelist, entityWhitelist)
-
-    if (allowlistNewFormat) {
-      // seperate into single entities /services for better processing
-      for (const permission of allowlistNewFormat) {
-        if (permission.for) {
-          for (const name of permission.for) {
-            if (permission.kind) {
-              // kind is specfied
-              result[permission.kind] = result[permission.kind] || {}
-              result[permission.kind][name] = permission
-            } else {
-              // check kind
-              if (fullCsn.definitions[name]) {
-                result[fullCsn.definitions[name].kind] = result[fullCsn.definitions[name].kind] || {}
-                result[fullCsn.definitions[name].kind][name] = permission
-              } else {
-                // allow all
-                result.all = result.all || {}
-                result.all[name] = permission
-              }
-            }
-          }
-        }
-      }
-    }
-    return result
-  }
-
-  static _addLegacyLists(result, serviceWhitelist, entityWhitelist) {
-    if (serviceWhitelist) {
-      result.service = result.service || {}
-      for (const service of serviceWhitelist) {
-        result.service[service] = {}
-      }
-    }
-
-    if (entityWhitelist) {
-      result.entity = result.entity || {}
-      for (const entity of entityWhitelist) {
-        result.entity[entity] = {}
-      }
-    }
-    return result
-  }
-
-  static _getLegacyLists(mtxConfig) {
-    let entityWhitelist = mtxConfig[LEGACY_ENTITY_WHITELIST]
-    let serviceWhitelist = mtxConfig[LEGACY_SERVICE_WHITELIST]
-
-    if (entityWhitelist && !Array.isArray(entityWhitelist)) {
-      entityWhitelist = [entityWhitelist]
-    }
-
-    if (serviceWhitelist && !Array.isArray(serviceWhitelist)) {
-      serviceWhitelist = [serviceWhitelist]
-    }
-    return { entityWhitelist, serviceWhitelist }
-  }
-}
-
-class AllowlistChecker extends Checker {
-  static _setupPermissionList(mtxConfig, fullCsn) {
-    return new Allowlist(mtxConfig, fullCsn)
-  }
-
-  static async check(reflectedExtensionCsn, fullCsn, extensionFiles, compileDir, mtxConfig) {
-    const allowList = this._setupPermissionList(mtxConfig, fullCsn)
-
-    const warnings = []
-
-    // check entities
-    if (reflectedExtensionCsn.extensions && allowList) {
-      for (const extension of reflectedExtensionCsn.extensions) {
-        this._checkEntity(extension, reflectedExtensionCsn, fullCsn, compileDir, allowList, warnings)
-      }
-    }
-
-    // check services
-    const foundServiceExt = {}
-    reflectedExtensionCsn.forall(
-      element => {
-        return ['entity', 'element', 'function', 'action'].includes(element.kind)
-      },
-      (element, name, parent) => {
-        if (allowList) {
-          this._checkService(
-            reflectedExtensionCsn,
-            fullCsn,
-            element,
-            parent,
-            { extensionFiles, compileDir },
-            allowList,
-            warnings,
-            foundServiceExt
-          ) // NOSONAR
-        }
-      }
-    )
-    this._addServiceLimitWarnings(foundServiceExt, allowList, compileDir, warnings)
-
-    return warnings
-  }
-
-  static _checkEntity(extension, extCsn, fullCsn, compileDir, allowlist, warnings) {
-    const extendedEntity = extension.extend
-    if (extendedEntity) {
-      if (
-        fullCsn &&
-        fullCsn.definitions &&
-        (!extCsn.definitions[extendedEntity] || extCsn.definitions[extendedEntity].kind !== 'entity')
-      ) {
-        const kind = this._getExtendedKind(fullCsn, extendedEntity)
-
-        if (!allowlist.isAllowed(kind, extendedEntity)) {
-          // not allowed at all
-          this._addColumnWarnings(extension, warnings, compileDir, allowlist.getList(kind), kind)
-          this._addElementWarnings(extension, warnings, compileDir, allowlist.getList(kind), kind)
-        } else {
-          // might have limits
-          this._addEntityLimitWarnings(extension, warnings, compileDir, allowlist, kind)
-        }
-      }
-    }
-  }
-
-  static _getExtendedKind(fullCsn, extendedEntity) {
-    const elementFromBase = fullCsn.definitions[extendedEntity]
-    return elementFromBase ? elementFromBase.kind : null
-  }
-
-  static _addElementWarnings(extension, warnings, compileDir, allowlist, kind) {
-    if (extension.elements) {
-      for (const element in extension.elements) {
-        warnings.push(
-          this._createAllowlistWarning(
-            extension.extend,
-            extension.elements[element],
-            compileDir,
-            allowlist,
-            LABELS[kind]
-          )
-        )
-      }
-    }
-  }
-
-  static _addColumnWarnings(extension, warnings, compileDir, allowlist, kind) {
-    // loop columns + elements
-    if (extension.columns) {
-      for (const column of extension.columns) {
-        warnings.push(this._createAllowlistWarning(extension.extend, column, compileDir, allowlist, LABELS[kind]))
-      }
-    }
-  }
-
-  static _addEntityLimitWarnings(extension, warnings, compileDir, allowlist, kind) {
-    const limit = allowlist.getPermission(kind, extension.extend)[NEW_FIELDS]
-
-    if (!limit) {
-      return
-    }
-
-    if (
-      (extension.columns ? extension.columns.length : 0) +
-        (extension.elements ? Object.keys(extension.elements).length : 0) <=
-      limit
-    ) {
-      return
-    }
-
-    // loop columns + elements
-    if (extension.columns) {
-      for (const column of extension.columns) {
-        warnings.push(this._createLimitWarning(extension.extend, column, compileDir, limit, LABELS[kind]))
-      }
-    }
-
-    if (extension.elements) {
-      for (const element in extension.elements) {
-        warnings.push(
-          this._createLimitWarning(extension.extend, extension.elements[element], compileDir, limit, LABELS[kind])
-        )
-      }
-    }
-  }
-
-  static _addServiceLimitWarnings(foundServiceExt, allowlist, compileDir, warnings) {
-    if (!allowlist) {
-      return
-    }
-
-    for (const service in foundServiceExt) {
-      let extLimit = allowlist.getPermission('service', service)[NEW_ENTITIES]
-      if (extLimit && extLimit <= foundServiceExt[service].length) {
-        // loop all extension for one service
-        for (const element of foundServiceExt[service]) {
-          warnings.push(this._createLimitWarning(service, element, compileDir, extLimit, LABELS['service']))
-        }
-      }
-    }
-  }
-
-  static _getParentName(element) {
-    if (element.name) {
-      const splitEntityName = element.name.split('.')
-      if (splitEntityName.length > 1) {
-        splitEntityName.pop()
-        return splitEntityName.join('.')
-      }
-    }
-    return null
-  }
-
-  static _isDefinedInExtension(reflectedCsn, name) {
-    return reflectedCsn.definitions ? !!reflectedCsn.definitions[name] : false
-  }
-
-  static _isDefinedInBasemodel(fullCsn, name) {
-    return !!this._getFromBasemodel(fullCsn, name)
-  }
-
-  static _getFromBasemodel(fullCsn, name) {
-    return fullCsn.definitions[name]
-  }
-
-  static _checkService(reflectedExtensionCsn, fullCsn, element, parent, extension, allowlist, warnings, foundExt) {
-    if (parent && parent.kind && parent.kind !== 'service') {
-      return
-    }
-
-    let parentName
-    if (!parent) {
-      parentName = this._getParentName(element)
-    } else {
-      parentName = this._getEntityName(parent)
-    }
-
-    // definition of element in extension itself
-    if (!parentName) {
-      return
-    }
-
-    // check if parent is defined in extension itself
-    if (this._isDefinedInExtension(reflectedExtensionCsn, parentName)) {
-      return
-    }
-
-    // check if parent is defined in basemodel
-    if (!this._isDefinedInBasemodel(fullCsn, parentName)) {
-      return
-    }
-
-    if (allowlist.isAllowed('service', parentName)) {
-      foundExt[parentName] = foundExt[parentName] || []
-      foundExt[parentName].push(element)
-      return
-    }
-
-    warnings.push(
-      this._createAllowlistWarning(parentName, element, extension.compileDir, allowlist.service, LABELS['service'])
-    )
-  }
-
-  static _createAllowlistWarning(entityName, element, compileDir, allowlist = {}, label) {
-    const originFile = this._localizeFile(element.$location.file, compileDir)
-
-    return (
-      label +
-      ' ' +
-      entityName +
-      ' must not be extended. See ' +
-      '(line:' +
-      element.$location.line +
-      ', col:' +
-      element.$location.col +
-      ')' +
-      ' in ' +
-      originFile +
-      '. Check ' +
-      label +
-      ' allowlist: ' +
-      (Object.keys(allowlist).length > 0 ? Object.keys(allowlist) : '<empty list>')
-    )
-  }
-
-  static _createLimitWarning(entityName, element, compileDir, limit, label) {
-    const originFile = this._localizeFile(element.$location.file, compileDir)
-
-    return (
-      `Extension limit of ${limit} for ${label} ${entityName} has been exceeded` +
-      `(line: ${element.$location.line}, col:  ${element.$location.col})` +
-      ` in ${originFile}`
-    )
-  }
-
-  static _getEntityName(entity) {
-    return entity.extend ? entity.extend : entity.name
-  }
-}
-
-module.exports = AllowlistChecker

package/libx/_runtime/extensibility/linter/annotations_checker.js

@@ -1,113 +0,0 @@
-const Checker = require('./checker_base')
-
-const AT_REQUIRES = '@requires'
-const AT_RESTRICT = '@restrict'
-const AT_CDS_PERSISTENCE_JOURNAL = '@cds.persistence.journal'
-const AT_SQL_APPEND = '@sql.append'
-const AT_SQL_PREPEND = '@sql.prepend'
-
-const checkedAnnotations = new Map([
-  [AT_REQUIRES, _createSecurityAnnotationWarning],
-  [AT_RESTRICT, _createSecurityAnnotationWarning],
-  [AT_CDS_PERSISTENCE_JOURNAL, _createJournalAnnotationWarning],
-  [AT_SQL_APPEND, _createSqlAnnotationWarning],
-  [AT_SQL_PREPEND, _createSqlAnnotationWarning]
-])
-
-function _createSqlAnnotationWarning(annotationName, originFile, annotation) {
-  return (
-    `Annotation ${annotationName} is not supported in extensions: ${originFile}` +
-    `(line: ${annotation.$location.line}, col: ${annotation.$location.col})`
-  )
-}
-
-function _createSecurityAnnotationWarning(annotationName, originFile, annotation) {
-  return (
-    `Security relevant annotation ${annotationName} cannot be overwritten: ${originFile}` +
-    `(line: ${annotation.$location.line}, col: ${annotation.$location.col})`
-  )
-}
-
-function _createJournalAnnotationWarning(journalAnnotationName, originFile, annotation) {
-  return (
-    `Enabling schema evolution in extensions using ${journalAnnotationName} not yet supported: ${originFile}` +
-    ` (line: ${annotation.$location.line}, col: ${annotation.$location.col})`
-  )
-}
-
-class AnnotationsChecker extends Checker {
-  static async check(reflectedCsn, extensionFiles, compileDir) {
-    if (!reflectedCsn.extensions) {
-      return []
-    }
-
-    // annotations via annotate - applies for all
-    const annotationExtensions = Object.values(reflectedCsn.extensions).filter(
-      value => value.annotate && Object.getOwnPropertyNames(value).filter(property => checkedAnnotations.get(property))
-    )
-
-    // check annotations for extensions including fields
-    reflectedCsn.forall(
-      () => true,
-      element => {
-        if (element[AT_SQL_PREPEND] || element[AT_SQL_APPEND]) {
-          if (!element.annotate) {
-            // do not add annotation extensions again
-            annotationExtensions.push(element)
-          }
-        }
-      },
-      reflectedCsn.extensions
-    )
-
-    // check entities and fields from definitions
-    const annotatedDefinitions = []
-    reflectedCsn.forall(
-      () => true,
-      element => {
-        if (element[AT_SQL_PREPEND] || element[AT_SQL_APPEND] || element[AT_CDS_PERSISTENCE_JOURNAL]) {
-          annotatedDefinitions.push(element)
-        }
-      },
-      reflectedCsn.definitions
-    )
-
-    const warnings = []
-
-    for (const annotationExtension of annotationExtensions) {
-      const warning = this._checkAnnotation(annotationExtension, reflectedCsn.definitions, compileDir)
-      if (warning) {
-        warnings.push(warning)
-      }
-    }
-
-    for (const annotatedDefinition of annotatedDefinitions) {
-      const warning = this._checkAnnotation(annotatedDefinition, reflectedCsn.definitions, compileDir)
-      if (warning) {
-        warnings.push(warning)
-      }
-    }
-
-    return warnings
-  }
-
-  static _checkAnnotation(annotation, definitions, compileDir) {
-    if (!definitions[annotation.annotate]) {
-      return this._createAnnotationsWarning(annotation, compileDir)
-    }
-
-    return null
-  }
-
-  static _createAnnotationsWarning(annotation, compileDir) {
-    const annotationName = Object.getOwnPropertyNames(annotation).filter(property => checkedAnnotations.get(property))
-
-    const originFile = this._localizeFile(annotation.$location.file, compileDir)
-
-    if (annotationName.length) {
-      return checkedAnnotations.get(annotationName[0])(annotationName, originFile, annotation)
-    }
-  }
-}
-
-module.exports = AnnotationsChecker

package/libx/_runtime/extensibility/linter/checker_base.js

@@ -1,20 +0,0 @@
-const path = require('path')
-
-class Checker {
-  static _isFromExtension(element, extensionFiles, compileDir) {
-    if (!element.$location) {
-      return false
-    }
-    const originFile = this._localizeFile(element.$location.file, compileDir)
-    return extensionFiles.includes(originFile)
-  }
-
-  static _localizeFile(filename, compileDir) {
-    if (path.isAbsolute(filename) || filename.startsWith('..')) {
-      filename = path.relative(compileDir, filename)
-    }
-    return filename.replace(/\\/g, '/')
-  }
-}
-
-module.exports = Checker