@sap/cds 5.5.4 → 5.6.2

package/libx/_runtime/common/aspects/Association.js

@@ -0,0 +1,72 @@
+// global.cds is used on purpose here!
+const cds = global.cds
+
+const ODATA_CONTAINED = '@odata.contained'
+
+const { isSelfManaged, isBacklink, getAnchor, getBacklink } = require('./utils')
+const { foreignKeyPropagations } = require('../utils/foreignKeyPropagations')
+
+module.exports = class {
+  get _isAssociationStrict() {
+    return (
+      this.own('__isAssociationStrict') ||
+      this.set('__isAssociationStrict', !!(this.isAssociation && !this.isComposition))
+    )
+  }
+
+  get _isAssociationEffective() {
+    return (
+      this.own('__isAssociationEffective') ||
+      this.set(
+        '__isAssociationEffective',
+        this._isAssociationStrict && (!this[ODATA_CONTAINED] || this.name === 'DraftAdministrativeData')
+      )
+    )
+  }
+
+  get _isCompositionEffective() {
+    return (
+      this.own('__isCompositionEffective') ||
+      this.set(
+        '__isCompositionEffective',
+        this.isComposition ||
+          (this._isAssociationStrict && this[ODATA_CONTAINED] && this.name !== 'DraftAdministrativeData')
+      )
+    )
+  }
+
+  get _isContained() {
+    return (
+      this.own('__isContained') ||
+      this.set(
+        '__isContained',
+        this.name !== 'DraftAdministrativeData_DraftUUID' &&
+          ((this.isAssociation && this[ODATA_CONTAINED]) || (this.isComposition && cds.env.effective.odata.containment))
+      )
+    )
+  }
+
+  get _isSelfManaged() {
+    return this.own('__isSelfManaged') || this.set('__isSelfManaged', isSelfManaged(this))
+  }
+
+  get _isBacklink() {
+    return this.own('__isBacklink') || this.set('__isBacklink', isBacklink(this))
+  }
+
+  get _isCompositionBacklink() {
+    return this.own('__isCompositionBacklink') || this.set('__isCompositionBacklink', isBacklink(this, true))
+  }
+
+  get _anchor() {
+    return this.own('__anchor') || this.set('__anchor', getAnchor(this))
+  }
+
+  get _backlink() {
+    return this.own('__backlink') || this.set('__backlink', getBacklink(this))
+  }
+
+  get _foreignKeys() {
+    return this.own('__foreignKeys') || this.set('__foreignKeys', foreignKeyPropagations(this))
+  }
+}

package/libx/_runtime/common/aspects/any.js

@@ -1,54 +1,12 @@
-// global.cds is used on purpose here!
-const cds = global.cds
-
-const ODATA_CONTAINED = '@odata.contained'
-
-const { isMandatory, isReadOnly } = require('./utils')
+const { getRelations, isMandatory, isReadOnly } = require('./utils')
 
+// NOTE: Please only add things which are relevant to _any_ type,
+// use specialized types otherwise (entity, Association, ...).
 module.exports = class {
-  get _isAssociationStrict() {
-    return (
-      this.own('__isAssociationStrict') ||
-      this.set('__isAssociationStrict', !!(this.isAssociation && !this.isComposition))
-    )
-  }
-
-  get _isAssociationEffective() {
-    return (
-      this.own('__isAssociationEffective') ||
-      this.set(
-        '__isAssociationEffective',
-        this._isAssociationStrict && (!this[ODATA_CONTAINED] || this.name === 'DraftAdministrativeData')
-      )
-    )
-  }
-
-  get _isCompositionEffective() {
-    return (
-      this.own('__isCompositionEffective') ||
-      this.set(
-        '__isCompositionEffective',
-        this.isComposition ||
-          (this._isAssociationStrict && this[ODATA_CONTAINED] && this.name !== 'DraftAdministrativeData')
-      )
-    )
-  }
-
   get _isStructured() {
     return this.own('__isStructured') || this.set('__isStructured', !!this.elements && this.kind !== 'entity')
   }
 
-  get _isContained() {
-    return (
-      this.own('__isContained') ||
-      this.set(
-        '__isContained',
-        this.name !== 'DraftAdministrativeData_DraftUUID' &&
-          ((this.isAssociation && this[ODATA_CONTAINED]) || (this.isComposition && cds.env.effective.odata.containment))
-      )
-    )
-  }
-
   get _isMandatory() {
     return this.own('__isMandatory') || this.set('__isMandatory', !this.isAssociation && isMandatory(this))
   }
@@ -56,4 +14,9 @@ module.exports = class {
   get _isReadOnly() {
     return this.own('__isReadOnly') || this.set('__isReadOnly', !this.key && isReadOnly(this))
   }
+
+  // REVISIT: Where to put?
+  get _relations() {
+    return this.own('__relations') || this.set('__relations', getRelations(this))
+  }
 }

package/libx/_runtime/common/aspects/entity.js

@@ -44,7 +44,6 @@ module.exports = class {
     // lazily require on first use
     getSearchableColumns =
       getSearchableColumns || require('../../cds-services/services/utils/columns').getSearchableColumns
-
     return this.own('__searchableColumns') || this.set('__searchableColumns', getSearchableColumns(this))
   }
 

package/libx/_runtime/common/aspects/relation.js

@@ -0,0 +1,40 @@
+const { getOnCond } = require('../utils/generateOnCond')
+
+let initializing = false
+
+module.exports = class Relation {
+  constructor(csn, path = []) {
+    if (!initializing) throw new Error(`Do not new a relation, use 'Relation.to()' instead`)
+    Object.defineProperty(this, 'csn', { get: () => csn })
+    Object.defineProperty(this, 'path', {
+      get: () => path,
+      set: _ => {
+        path = _
+      }
+    })
+    if (csn.target) Object.defineProperty(this, 'target', { get: () => csn.target })
+    initializing = false
+  }
+
+  static to(from, name) {
+    initializing = true
+    if (!name) return new Relation(from)
+    return from._elements[name] && new Relation(from._elements[name], [...from.path, name])
+  }
+
+  _has(prop) {
+    return Reflect.has(this, prop) && !this._elements[prop]
+  }
+
+  get _elements() {
+    if (this.csn.elements) return this.csn.elements
+    if (this.csn._target && this.csn._target.elements) return this.csn._target.elements
+    // if (csn.targetAspect) relation.elements = model.definitions[csn.targetAspect].elements
+    // if (csn.kind = 'type') relation.elements = model.definitions[csn.type].element
+    return {}
+  }
+
+  join(fromAlias = '', toAlias = '') {
+    return getOnCond(this.csn, this.path, { select: fromAlias, join: toAlias })
+  }
+}

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

@@ -1,3 +1,5 @@
+const Relation = require('./relation')
+
 const CommonFieldControl = e => {
   const cfr = e['@Common.FieldControl']
   return cfr && cfr['#']
@@ -65,10 +67,80 @@ const hasSensitiveData = entity => {
   return val
 }
 
+const _exposeRelation = relation => Object.defineProperty({}, '_', { get: () => relation })
+
+const _relationHandler = relation => ({
+  get: (target, name) => {
+    const path = name.split(',')
+    const prop = path.join('_')
+    if (!target[prop]) {
+      if (path.length === 1) {
+        // REVISIT: property 'join' must not be used in CSN to make this working
+        if (relation._has(prop)) return relation[prop]
+        const newRelation = Relation.to(relation, prop)
+        if (newRelation) {
+          target[prop] = new Proxy(_exposeRelation(newRelation), _relationHandler(newRelation))
+        }
+        return target[prop]
+      }
+      target[prop] = path.reduce((r, p) => r[p] || r.csn._relations[p], relation)
+      target[prop].path = path
+    }
+    return target[prop]
+  }
+})
+
+const getRelations = e => {
+  const newRelation = Relation.to(e)
+  return new Proxy(_exposeRelation(newRelation), _relationHandler(newRelation))
+}
+
+const _hasJoinCondition = e => e.isAssociation && e.on && e.on.length > 2
+
+const _isSelfRef = e => e.ref && e.ref[0] === '$self'
+
+const _getBacklinkName = on => {
+  const i = on.findIndex(_isSelfRef)
+  if (i === -1) return
+  let ref
+  if (on[i + 1] && on[i + 1] === '=') ref = on[i + 2].ref
+  if (on[i - 1] && on[i - 1] === '=') ref = on[i - 2].ref
+  return ref && ref[ref.length - 1]
+}
+
+const isSelfManaged = e => {
+  if (!_hasJoinCondition(e)) return
+  return !!e.on.find(_isSelfRef)
+}
+
+const isBacklink = (e, checkComposition) => getAnchor(e, checkComposition) && true
+
+const _isUnManagedAssociation = (e, checkComposition) =>
+  e.isAssociation && (!checkComposition || e._isCompositionEffective) && _hasJoinCondition(e)
+
+const getAnchor = (e, checkComposition) => {
+  if (!(e._isAssociationStrict && (e.keys || e.on))) return
+  for (const anchor of Object.values(e._target.associations || {})) {
+    if (!_isUnManagedAssociation(anchor, checkComposition)) continue
+    if (_getBacklinkName(anchor.on) === e.name && anchor.target === e.parent.name) return anchor
+  }
+}
+
+const getBacklink = (e, checkComposition) => {
+  if (!_isUnManagedAssociation(e, checkComposition)) return
+  const backlinkName = _getBacklinkName(e.on)
+  if (backlinkName) return e._target && e._target.elements && e._target.elements[backlinkName]
+}
+
 module.exports = {
   isMandatory,
   isReadOnly,
   getETag,
   hasPersonalData,
-  hasSensitiveData
+  hasSensitiveData,
+  getRelations,
+  isSelfManaged,
+  isBacklink,
+  getAnchor,
+  getBacklink
 }

package/libx/_runtime/common/auth/strategies/utils/uaa.js

@@ -1,21 +1,17 @@
 const cds = require('../../../../cds')
 
-const _require = require('../../../utils/require')
-
 const getCredentials = uaa => {
-  uaa = uaa || cds.env.requires.uaa || {}
+  uaa =
+    uaa && uaa.credentials
+      ? uaa
+      : cds.env.requires.uaa && cds.env.requires.uaa.credentials
+      ? cds.env.requires.uaa
+      : cds.env.requires.xsuaa && cds.env.requires.xsuaa.credentials
+      ? cds.env.requires.xsuaa
+      : {}
 
-  if (!uaa.credentials) {
-    try {
-      const vcap = cds.env.requires.uaa && cds.env.requires.uaa.vcap
-      uaa.credentials = _require('@sap/xsenv').serviceCredentials(vcap || { label: 'xsuaa' })
-    } catch (e) {
-      const msg =
-        'Unable to get xsuaa credentials. Please make sure your app is bound to a single xsuaa service instance or that you provide vcap information in the requires.uaa section.'
-      // REVISIT: switch to verror
-      throw Object.assign(new Error(msg), { original: e })
-    }
-  }
+  if (!uaa.credentials)
+    throw Object.assign(new Error('No or malformed uaa credentials'), { credentials: uaa.credentials })
 
   return uaa.credentials
 }

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

@@ -4,8 +4,9 @@ const { getEntityNameFromUpdateCQN } = require('../utils/cqn')
 
 const { ensureNoDraftsSuffix } = require('../utils/draft')
 const { getDBTable } = require('../utils/resolveView')
-const cqn2cqn4sql = require('../utils/cqn2cqn4sql')
+const { cqn2cqn4sql } = require('../utils/cqn2cqn4sql')
 const cds = require('../../cds')
+const { SELECT } = cds.ql
 
 /*
  * own utils
@@ -192,7 +193,7 @@ const _select = ({
 }) => {
   const entity = definitions && definitions[entityName]
   const from = ctUtils.addDraftSuffix(draft, entity.name)
-  const selectCQN = { SELECT: { from: { ref: [from] } } }
+  const selectCQN = SELECT.from(from)
   if (alias) selectCQN.SELECT.from.as = alias
   const selectAll = includeAllColumns || (includeAllRootColumns && root)
   selectCQN.SELECT.columns = _columns(entity, data, compositionTree, selectAll)

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

@@ -20,8 +20,10 @@ const _recursivelyAliasRefs = (something, newAlias, oldAlias, subselect = false)
       if (oldAlias && something.ref[0] === oldAlias) something.ref[0] = newAlias
       else if (!subselect) something.ref.unshift(newAlias)
     } else {
-      for (const key in something)
+      for (const key in something) {
+        if (key === 'from') continue // Workaround: Deep delete to be rewritten
         _recursivelyAliasRefs(something[key], newAlias, oldAlias, subselect || key === 'SELECT')
+      }
     }
   }
 }

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

@@ -1,13 +1,9 @@
 const cds = require('../../cds')
 
-const { isSelfManaged, isBacklink } = require('../utils/backlinks')
-
 const { ensureNoDraftsSuffix } = require('../utils/draft')
 const { isRootEntity } = require('../utils/csn')
 const { getTransition, getDBTable } = require('../utils/resolveView')
 
-const { foreignKeyPropagations } = require('../utils/foreignKeyPropagations')
-
 const getError = require('../../common/error')
 
 /*
@@ -15,21 +11,25 @@ const getError = require('../../common/error')
  */
 
 const _foreignKeysToLinks = (element, inverse) =>
-  foreignKeyPropagations(element).map(e => {
+  element._foreignKeys.map(e => {
     e = inverse
       ? {
-          childFieldName: e.parentFieldName,
-          parentFieldName: e.childFieldName,
+          childElement: e.parentElement,
+          parentElement: e.childElement,
           childFieldValue: e.parentFieldValue,
           parentFieldValue: e.childFieldValue,
           prefix: e.prefix
         }
       : e
-    const link = {
-      entityKey:
-        e.prefix && !e.parentFieldName.includes(e.prefix) ? e.prefix + '_' + e.parentFieldName : e.parentFieldName,
-      targetKey: e.prefix && !e.childFieldName.includes(e.prefix) ? e.prefix + '_' + e.childFieldName : e.childFieldName
-    }
+    const link = {}
+    if (e.parentElement)
+      link.entityKey =
+        e.prefix && !e.parentElement.name.includes(e.prefix)
+          ? `${e.prefix}_${e.parentElement.name}`
+          : e.parentElement.name
+    if (e.childElement)
+      link.targetKey =
+        e.prefix && !e.childElement.name.includes(e.prefix) ? `${e.prefix}_${e.childElement.name}` : e.childElement.name
     if (e.parentFieldValue !== undefined) link.entityVal = e.parentFieldValue
     if (e.childFieldValue !== undefined) link.targetVal = e.childFieldValue
     return link
@@ -57,7 +57,7 @@ const _resolvedElement = (element, service) => {
 const _navigationExistsInCompositionMap = (element, compositionMap) =>
   compositionMap.has(element.target) && element._isCompositionEffective
 
-const _isUnManaged = element => element.on && !isSelfManaged(element)
+const _isUnManaged = element => element.on && !element._isSelfManaged
 
 const _isNonRecursiveNavigation = (element, rootEntityName) =>
   rootEntityName !== element.target && element._isCompositionEffective
@@ -106,7 +106,7 @@ const _getCompositionTreeRec = ({
         backLinks: [],
         customBackLinks: []
       })
-      if (!isSelfManaged(element)) {
+      if (!element._isSelfManaged) {
         const backLinks = _foreignKeysToLinks(element, true) || []
         if (element.is2many) {
           compositionElement.customBackLinks.push(...backLinks)
@@ -118,7 +118,11 @@ const _getCompositionTreeRec = ({
         for (const backLinkName in targetEntity.elements) {
           const _backLink = targetEntity.elements[backLinkName]
           if (!_backLink._isAssociationEffective) continue
-          if (isBacklink(_backLink, definitions[compositionElement.target], false, element.name)) {
+          if (
+            _backLink._isCompositionBacklink &&
+            _backLink.target === compositionElement.target &&
+            _backLink._anchor.name === element.name
+          ) {
             const backLinks = _foreignKeysToLinks(_backLink) || []
             if (_isUnManaged(element)) {
               compositionElement.customBackLinks.push(...backLinks)
@@ -131,7 +135,7 @@ const _getCompositionTreeRec = ({
       compositionTree.compositionElements.push(compositionElement)
     } else if (_isNonRecursiveNavigation(element, rootEntityName)) {
       const subObject = _createSubElement(element, definitions)
-      if (!isSelfManaged(element)) {
+      if (!element._isSelfManaged) {
         const backLinks = _foreignKeysToLinks(element, true) || []
         if (element.is2many) {
           subObject.customBackLinks.push(...backLinks)
@@ -151,7 +155,8 @@ const _getCompositionTreeRec = ({
       })
     } else if (
       element._isAssociationEffective &&
-      isBacklink(element, definitions[compositionTree.target], false, compositionTree.name) &&
+      element._isCompositionBacklink &&
+      element.target === compositionTree.target &&
       compositionMap.has(element.target)
     ) {
       const backLinks = _foreignKeysToLinks(element) || []
@@ -218,7 +223,7 @@ const _cacheCompositionParentsOfOne = ({ definitions }) => {
     if (!parent.kind === 'entity' || !parent.elements) continue
     for (const elementName in parent.elements) {
       const element = parent.elements[elementName]
-      if (element._isCompositionEffective && element.is2one && !isSelfManaged(element)) {
+      if (element._isCompositionEffective && element.is2one && !element._isSelfManaged) {
         const targetName = element.target
         const target = definitions[targetName]
         if (!target) continue

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

@@ -205,11 +205,16 @@ function _addSubDeepUpdateCQNRecursion({ definitions, compositionTree, entity, d
     const selectSubData = []
     for (const entry of data) {
       if (element.name in entry) {
-        _addToData(subData, entity, element, entry)
         const selectEntry = selectDataByKey.get(_serializedKey(entity, entry))
+
         if (selectEntry && element.name in selectEntry) {
+          if (selectEntry[element.name] === null && Object.keys(entry[element.name]).length === 0) {
+            continue
+          }
           _addToData(selectSubData, entity, element, selectEntry)
         }
+
+        _addToData(subData, entity, element, entry)
       }
     }
     _addSubDeepUpdateCQN({

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

@@ -1,5 +1,3 @@
-const { isSelfManaged } = require('../utils/backlinks')
-
 const { ensureNoDraftsSuffix, ensureDraftsSuffix } = require('../utils/draft')
 
 const addDraftSuffix = (draft, name) => {
@@ -24,6 +22,7 @@ const keyElements = entity => {
 
 const key = (entity, data) => {
   return keyElements(entity).reduce((result, element) => {
+    if (element.name === 'IsActiveEntity' && !Object.prototype.hasOwnProperty.call(data, element.name)) return result
     result[element.name] = data[element.name]
     return result
   }, {})
@@ -33,10 +32,6 @@ const val = element => (element && element.val) || element
 
 const array = x => (Array.isArray(x) ? x : [x])
 
-const isManaged = element => {
-  return isSelfManaged(element) || !element.on
-}
-
 const isCompOrAssoc = (entity, k, onlyToOne) => {
   return (
     entity.elements &&
@@ -60,6 +55,37 @@ const cleanDeepData = (entity, data, onlyToOne = false) => {
   })
 }
 
+const _getBacklinkNameFromOnCond = element => {
+  if (element.on && element.on.length === 3 && element.on[0].ref && element.on[2].ref) {
+    if (element.on[0].ref[0] === '$self') {
+      return element.on[2].ref[element.on[2].ref.length - 1]
+    } else if (element.on[2].ref[0] === '$self') {
+      return element.on[0].ref[element.on[0].ref.length - 1]
+    }
+  }
+}
+
+const isBacklink = (element, parent, checkContained, backLinkName) => {
+  if (!element._isAssociationStrict) return false
+  if (!parent || !(element.keys || element.on)) return false
+  if (element.target !== parent.name) return false
+
+  const _isBackLink = parentElement =>
+    (!checkContained || parentElement._isContained) && _getBacklinkNameFromOnCond(parentElement) === element.name
+
+  if (backLinkName) {
+    const parentElement = parent.elements[backLinkName]
+    return parentElement.isAssociation && _isBackLink(parentElement)
+  }
+  for (const parentElementName in parent.elements) {
+    const parentElement = parent.elements[parentElementName]
+    if (!parentElement.isAssociation) continue
+    if (_isBackLink(parentElement)) return true
+  }
+
+  return false
+}
+
 module.exports = {
   addDraftSuffix,
   whereKey,
@@ -67,7 +93,7 @@ module.exports = {
   key,
   val,
   array,
-  isManaged,
   isCompOrAssoc,
-  cleanDeepData
+  cleanDeepData,
+  isBacklink
 }

package/libx/_runtime/common/error/frontend.js

@@ -22,6 +22,8 @@ const {
   MAX_SEVERITY
 } = require('./constants')
 
+const SKIP_SANITIZATION = '@cds.skip_sanitization'
+
 const _getFiltered = err => {
   const error = {}
 
@@ -103,10 +105,13 @@ const normalizeError = (err, req) => {
   // make sure it's a number
   statusCode = statusCode ? Number(statusCode) : 500
 
-  if (statusCode >= 500 && process.env.NODE_ENV === 'production') {
+  // REVISIT: make === 500 in cds^6
+  // error[SKIP_SANITIZATION] is not an official API!!!
+  if (statusCode >= 500 && process.env.NODE_ENV === 'production' && !error[SKIP_SANITIZATION]) {
     // > return sanitized error to client
     return { error: { code: `${statusCode}`, message: i18n(statusCode, locale) }, statusCode }
   }
+  delete error[SKIP_SANITIZATION]
 
   // no top level null codes
   if (error.code === 'null') {

package/libx/_runtime/common/generic/auth.js

@@ -6,7 +6,7 @@ const cds = require('../../cds')
 const { SELECT } = cds.ql
 
 const { getRequiresAsArray } = require('../utils/auth')
-const cqn2cqn4sql = require('../utils/cqn2cqn4sql')
+const { cqn2cqn4sql } = require('../utils/cqn2cqn4sql')
 const { isActiveEntityRequested, removeIsActiveEntityRecursively } = require('../../fiori/utils/where')
 const { ensureDraftsSuffix } = require('../../fiori/utils/handler')
 
@@ -204,9 +204,10 @@ const _findTableName = (ref, aliases) => {
 
 const _getTableForColumn = (col, aliases, model) => {
   for (let i = 0; i < aliases.length; i++) {
-    const alias = aliases[i]
+    const index = aliases.length - i - 1
+    const alias = aliases[index]
     if (Object.keys(model.definitions[alias].elements).includes(col)) {
-      return { index: i, table: alias.replace(/\./g, '_') }
+      return { index, table: alias.replace(/\./g, '_') }
     }
   }
 
@@ -549,13 +550,18 @@ const _addNormalizedRestrict = (restrict, restricts, definition, definitions) =>
     if (where) {
       // operate on a copy
       let _where = where
-      const paths = where.match(/ (\w*)\.(\w*)/g) || []
+      // find all path expressions in order to normalize shorthand (i.e., inject "[exists ...]")
+      const paths = (where.match(/ (\w\.*)*/g) || []).filter(m => m.match(/\./) && m !== ' ')
       for (let i = 0; i < paths.length; i++) {
         const parts = paths[i].trim().split('.')
         let current = definition
         while (parts.length) {
           current = current.elements[parts.shift()]
-          if (current.is2many) _where = _where.replace(current.name + '.', current.name + '[exists ') + ']'
+          if (current.isAssociation && _where.includes(current.name + '.')) {
+            const matches = _where.match(new RegExp(`(${current.name}).(.*)]`))
+            _where = _where.replace(`${matches[1]}.`, `${current.name}[exists `)
+            _where = _where.replace(matches[2], `${matches[2]}]`)
+          }
           if (current.target) current = definitions[current.target]
         }
       }
@@ -882,19 +888,15 @@ const _secureDependentEntities = srv => {
   }
 }
 
-module.exports = function () {
-  /*
-   * @restrict, @requires, @readonly, @insertonly, and @Capabilities for entities
-   */
+module.exports = cds.service.impl(function () {
+  // @restrict, @requires, @readonly, @insertonly, and @Capabilities for entities
   _secureDependentEntities(this)
   for (const k in this.entities) {
     const entity = this.entities[k]
     if (!_authDependsOnParents(entity)) _registerAuthHandlers(entity, this)
   }
 
-  /*
-   * @restrict and @requires for operations
-   */
+  // @restrict and @requires for operations
   for (const k in this.operations) {
     const operation = this.operations[k]
 
@@ -904,4 +906,4 @@ module.exports = function () {
     // @restrict
     _registerOperationRestrictHandlers(operation, this)
   }
-}
+})

package/libx/_runtime/common/generic/crud.js

@@ -67,7 +67,7 @@ const _updateReqData = (req, that) => {
   }
 }
 
-module.exports = function () {
+module.exports = cds.service.impl(function () {
   this.on(['CREATE', 'READ', 'UPDATE', 'DELETE'], '*', async function (req) {
     if (typeof req.query !== 'string' && req.target && req.target._hasPersistenceSkip) {
       req.reject(501, 'PERSISTENCE_SKIP_NO_GENERIC_CRUD', [req.target.name])
@@ -128,4 +128,4 @@ module.exports = function () {
 
     return req.data
   })
-}
+})