@sap/cds 5.5.4 → 5.6.2

package/libx/_runtime/fiori/generic/prepare.js

@@ -50,8 +50,8 @@ const _handler = async function (req) {
   return result[0]
 }
 
-module.exports = function () {
+module.exports = cds.service.impl(function () {
   for (const entity of Object.values(this.entities).filter(e => e._isDraftEnabled)) {
     this.on('draftPrepare', entity, _handler)
   }
-}
+})

package/libx/_runtime/fiori/generic/read.js

@@ -1,7 +1,7 @@
 const cds = require('../../cds')
 const { SELECT } = cds.ql
 
-const cqn2cqn4sql = require('../../common/utils/cqn2cqn4sql')
+const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
 const { getElementDeep } = require('../../common/utils/csn')
 
 const { DRAFT_COLUMNS, DRAFT_COLUMNS_MAP, SCENARIO } = require('../../common/constants/draft')
@@ -15,7 +15,6 @@ const {
   getEnrichedCQN,
   removeDraftUUIDIfNecessary,
   replaceRefWithDraft,
-  hasKeyInWhere,
   filterKeys
 } = require('../utils/handler')
 const { deleteCondition, readAndDeleteKeywords, removeIsActiveEntityRecursively } = require('../utils/where')
@@ -186,34 +185,6 @@ function _copyArray(array) {
   })
 }
 
-const _whereContainsKeys = (req, whereDraft) => {
-  const keys = _getTargetKeys(req)
-  if (whereDraft.length < keys.length * 4 - 1) {
-    return false
-  }
-
-  let i = 0
-  let keyCount = 0
-  while (i < whereDraft.length) {
-    const element = whereDraft[i]
-    const op = whereDraft[i + 1]
-    if (element.ref && keys.some(x => x === element.ref[element.ref.length - 1]) && op === '=') {
-      // op is EQ by keys
-      i = i + 4
-      keyCount++
-      continue
-    }
-
-    i++
-  }
-
-  return keyCount === keys.length
-}
-
-const _isValidActive = (isActiveEntity, req, whereDraft) => {
-  return isActiveEntity.op === '=' && _isTrue(isActiveEntity.value.val) && _whereContainsKeys(req, whereDraft)
-}
-
 const _isValidDraftOfWhichIAmOwner = isActiveEntity => {
   return isActiveEntity.op === '=' && _isFalse(isActiveEntity.value.val)
 }
@@ -275,7 +246,7 @@ const _filterDraftColumnsBySelected = (draftColumns, columns) => {
   )
 }
 
-const _isOnlyCount = columns => columns.length === 1 && columns[0].as === '_counted_'
+const _isOnlyCount = columns => columns.length === 1 && (columns[0].as === '_counted_' || columns[0].as === '$count')
 
 const _getOuterMostColumns = (columnsFromRequest, additionalDraftColumns) => {
   if (_isOnlyCount(columnsFromRequest)) return columnsFromRequest
@@ -428,18 +399,6 @@ const _allActive = (req, columns, model) => {
   }
 }
 
-const _active = (req, draftWhere, columns) => {
-  const { table } = _getTableName(req)
-
-  const outerMostColumns = _getOuterMostColumns(columns, _getDraftPropertiesDetermineDraft(req, draftWhere))
-
-  const cqn = SELECT.from(table).columns(...outerMostColumns)
-
-  draftWhere = _getWhereWithAppendedDraftRestrictions(draftWhere, req)
-
-  return { cqn: getEnrichedCQN(cqn, req.query.SELECT, draftWhere), scenario: SCENARIO.ACTIVE }
-}
-
 const _activeWithoutDraft = (req, draftWhere, columns) => {
   const { table } = _getTableName(req, true)
   const draftName = table.ref[0]
@@ -805,7 +764,7 @@ const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere) => {
         _alignAliasForUnion(ensureNoDraftsSuffix(req.target.name), req.query.SELECT.from.as, subSelect)
       ])
 
-    return union.columns({ func: 'sum', args: [{ ref: ['_counted_'] }], as: '_counted_' })
+    return union.columns({ func: 'sum', args: [{ ref: ['$count'] }], as: '$count' })
   }
 
   const enrichedColumns = _getOrderByEnrichedColumns(req.query.SELECT.orderBy, columns)
@@ -941,9 +900,6 @@ const _validatedWithSiblingInProcess = (req, draftWhere, draftParameters, column
   }
 }
 
-const _validatedActive = (req, draftWhere, draftParameters, columns) =>
-  _isValidActive(draftParameters.isActiveEntity, req, draftWhere) && _active(req, draftWhere, columns)
-
 const _validatedDraftOfWhichIAmOwner = (req, draftWhere, draftParameters, columns) =>
   _isValidDraftOfWhichIAmOwner(draftParameters.isActiveEntity) && _draftOfWhichIAmOwner(req, draftWhere, columns)
 
@@ -989,20 +945,16 @@ const _generateCQN = (reqOriginal, req, columns, model) => {
     return _allActive(req, columns, model)
   }
 
-  if (req.query.SELECT.where.length === 1 && req.query.SELECT.where[0].xpr) {
-    // REVISIT ugly workaround until we support .xpr instead of '('...')' in draft choreo
-    req.query.SELECT.where = req.query.SELECT.where[0].xpr
-  }
+  // REVISIT this function does not only read, but modifies where!
   const draftParameters = _readDraftParameters(req.query.SELECT.where)
 
   if (
     draftParameters.isActiveEntity &&
     _isTrue(draftParameters.isActiveEntity.value.val) &&
     !draftParameters.siblingIsActive &&
-    !draftParameters.hasDraftEntity &&
-    !hasKeyInWhere(reqOriginal.query.SELECT.from.ref[0].where, model.definitions[req.query.SELECT.from.ref[0]])
+    !draftParameters.hasDraftEntity
   ) {
-    return _allActive(req, columns)
+    return _allActive(req, columns, model)
   }
 
   if (!draftParameters.isActiveEntity) {
@@ -1012,7 +964,7 @@ const _generateCQN = (reqOriginal, req, columns, model) => {
       // this is only the case when navigating into tree
       return _allInactive(req, columns)
     }
-    return _allActive(req, columns)
+    return _allActive(req, columns, model)
   }
 
   if (draftParameters.hasDraftEntity) {
@@ -1023,9 +975,7 @@ const _generateCQN = (reqOriginal, req, columns, model) => {
     return _validatedWithSiblingInProcess(req, req.query.SELECT.where, draftParameters, columns)
   }
 
-  return _isTrue(draftParameters.isActiveEntity.value.val)
-    ? _validatedActive(req, req.query.SELECT.where, draftParameters, columns)
-    : _validatedDraftOfWhichIAmOwner(req, req.query.SELECT.where, draftParameters, columns)
+  return _validatedDraftOfWhichIAmOwner(req, req.query.SELECT.where, draftParameters, columns)
 }
 
 const _getColumns = ({ query: { SELECT } }, model) => {
@@ -1183,7 +1133,7 @@ const _handler = async function (req) {
   delete req.query._validationQuery
 
   // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
-  const sqlQuery = cqn2cqn4sql(req.query, this.model)
+  const sqlQuery = cqn2cqn4sql(req.query, this.model, { draft: true })
 
   // do not clone with Object.assign as that would skip all non-enumerable properties
   const reqClone = { __proto__: req, query: _copyCQNPartial(sqlQuery) }
@@ -1204,7 +1154,11 @@ const _handler = async function (req) {
     return
   }
 
-  const enhacnedWithLastChangeDateTime = enhanceQueryForTimeoutIfNeeded(
+  if (cqnScenario.scenario === SCENARIO.ALL_ACTIVE && cqnScenario.cqn.SELECT.where) {
+    cqnScenario.cqn.SELECT.where = removeIsActiveEntityRecursively(cqnScenario.cqn.SELECT.where)
+  }
+
+  const enhancedWithLastChangeDateTime = enhanceQueryForTimeoutIfNeeded(
     cqnScenario.scenario,
     cqnScenario.cqn.SELECT.columns
   )
@@ -1228,7 +1182,7 @@ const _handler = async function (req) {
     _calculateDraftAdminColumns(resultAsArray[0], req.user.id)
   }
 
-  calculateDraftTimeout(cqnScenario.scenario, resultAsArray, enhacnedWithLastChangeDateTime)
+  calculateDraftTimeout(cqnScenario.scenario, resultAsArray, enhancedWithLastChangeDateTime)
 
   if (cqnScenario.scenario === SCENARIO.SIBLING_ENTITY) {
     if (!result || (Array.isArray(result) && !result.length)) return result
@@ -1247,8 +1201,8 @@ const _handler = async function (req) {
   return result
 }
 
-module.exports = function () {
+module.exports = cds.service.impl(function () {
   for (const entity of Object.values(this.entities).filter(e => e._isDraftEnabled)) {
     this.on('READ', entity, _handler)
   }
-}
+})

package/libx/_runtime/fiori/generic/readOverDraft.js

@@ -2,7 +2,7 @@ const cds = require('../../cds')
 const { SELECT } = cds.ql
 const { getEnrichedCQN, hasDraft, ensureDraftsSuffix } = require('../utils/handler')
 const { readAndDeleteKeywords } = require('../utils/where')
-const cqn2cqn4sql = require('../../common/utils/cqn2cqn4sql')
+const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
 
 const _modifyCQN = (cqnDraft, where, context) => {
   const whereDraft = [...where]
@@ -45,7 +45,7 @@ const _handler = async function (req) {
   }
 
   // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
-  const sqlQuery = cqn2cqn4sql(req.query, this.model)
+  const sqlQuery = cqn2cqn4sql(req.query, this.model, { draft: true })
   if (req.query._streaming) {
     sqlQuery._streaming = true
   }
@@ -70,8 +70,8 @@ const _handler = async function (req) {
   return cds.tx(req).run(sqlQuery)
 }
 
-module.exports = function () {
+module.exports = cds.service.impl(function () {
   for (const entity of Object.values(this.entities).filter(e => !e._isDraftEnabled)) {
     this.on('READ', entity, _handler)
   }
-}
+})

package/libx/_runtime/fiori/uiflex/extensibility/index.cds

@@ -0,0 +1,15 @@
+namespace cds_r; //> cds system tables
+
+service ExtensibilityService @(path:'/-/cds/extensibility') {
+  action addExtension(extensions : array of String); // TODO: change to array of CSN extensions
+}
+
+entity Extensions {
+  key ID : UUID;
+  csn    : String;
+}
+
+// @open type Extension {
+//   extend: String;
+//   elements:{ /*  */ }
+// }

package/libx/_runtime/fiori/uiflex/extensibility/index.js

@@ -0,0 +1,148 @@
+const cds = require('../../../cds')
+const { ensureDraftsSuffix } = require('../../../common/utils/draft')
+
+const { EXT_BACK_PACK } = require('../utils')
+
+const _getDraftTable = (view, cds) => {
+  return cds.model.definitions[view]._isDraftEnabled ? ensureDraftsSuffix(view) : undefined
+}
+
+const _addAnnotation = extension => {
+  Object.values(extension.elements).forEach(el => {
+    el['@cds.extension'] = true
+  })
+}
+
+const _isProjection = target => target && target.query && target.query._target
+
+const _resolveViews = (target, views_ = []) => {
+  if (_isProjection(target)) {
+    views_.push(target)
+    return _resolveViews(target.query._target, views_)
+  }
+
+  return target
+}
+
+const _getCsn = req => {
+  const csn = {
+    extensions: req.data.extensions.map(ext => JSON.parse(ext))
+  }
+
+  return csn
+}
+
+const _addViews = csn => {
+  csn.extensions.forEach(extension => {
+    const target = cds.model.definitions[extension.extend]
+    const views_ = []
+    const view = _resolveViews(target, views_)
+    extension.extend = view && view.name
+    _addAnnotation(extension)
+
+    // All projection views leading to the db entity are extended with back pack in case view columns are explicitly listed.
+    // The views using projections with '*' obtain the back pack automatically.
+    views_.forEach(view => {
+      if (!view.projection || (view.projection.columns && !view.projection.columns.some(col => col === '*'))) {
+        csn.extensions.push({
+          extend: view.name,
+          columns: Object.keys(extension.elements).map(key => {
+            return { ref: [key] }
+          })
+        })
+      }
+    })
+  })
+}
+
+const _handleDefaults = async (extension, dbEntity, req, cds, draftEntity) => {
+  const ext = Object.keys(extension.elements)
+    .filter(key => extension.elements[key].default)
+    .map(key => {
+      const element = extension.elements[key]
+      const t = cds.model.definitions[element.type] || cds.builtin.types[element.type]
+      const value = t && t instanceof cds.builtin.classes.string ? `"${element.default.val}"` : element.default.val
+      return `"${key}":${value}`
+    })
+
+  if (ext.length !== 0) {
+    const extStr = ext.join(',')
+    const changed = `'{${extStr},' || substr(${EXT_BACK_PACK}, 2, length(${EXT_BACK_PACK})-1)`
+    const assign = `${EXT_BACK_PACK} = CASE WHEN ${EXT_BACK_PACK} IS NULL THEN '{${extStr}}' ELSE ${changed} END`
+    await UPDATE(dbEntity).with(assign)
+    if (draftEntity) await UPDATE(draftEntity).with(assign)
+  }
+}
+
+const _validateCsn = (csn, req) => {
+  csn.extensions.forEach(extension => {
+    if (!extension.extend || !cds.model.definitions[extension.extend]) {
+      req.reject(400, 'Invalid extension. Parameter "extend" missing or malformed')
+    }
+
+    if (!extension.elements) {
+      req.reject(400, 'Invalid extension. Missing parameter "elements"')
+    }
+  })
+}
+
+const _validateExtensionFields = async (csn, req) => {
+  csn.extensions.forEach(extension => {
+    if (extension.elements) {
+      Object.keys(extension.elements).forEach(name => {
+        if (!/^[A-Za-z]\w*$/.test(name)) {
+          req.reject(400, `Invalid extension. Bad element name "${name}"`)
+        }
+
+        if (Object.keys(cds.model.definitions[extension.extend].elements).includes(name)) {
+          req.reject(400, `Invalid extension. Element "${name}" already exists`)
+        }
+      })
+    }
+  })
+}
+
+const _getCompilerError = messages => {
+  const defaultMsg = 'Error while compiling extension'
+  if (!messages) return defaultMsg
+
+  for (const msg of messages) {
+    if (msg.severity === 'Error') return msg.message
+  }
+
+  return defaultMsg
+}
+
+const _validateExtension = async (csn, req) => {
+  try {
+    const base = await cds.load('*', cds.options)
+    const baseCsn = await cds.compile.to.json(base)
+    const extCsn = await cds.compile.to.json(csn)
+    await cds.compile.to.csn({ 'base.csn': baseCsn, 'ext.csn': extCsn })
+  } catch (err) {
+    req.reject(400, _getCompilerError(err.messages))
+  }
+}
+
+module.exports = function () {
+  this.on('addExtension', async req => {
+    const csn = _getCsn(req, cds)
+    _validateCsn(csn, req)
+    await _validateExtensionFields(csn, req)
+    _addViews(csn, cds)
+    await _validateExtension(csn, req)
+
+    const ID = cds.utils.uuid()
+    await INSERT.into('cds_r.Extensions').entries([{ ID, csn: JSON.stringify(csn) }])
+
+    for (const ext of req.data.extensions) {
+      const extension = JSON.parse(ext)
+      const draft = _getDraftTable(extension.extend, cds)
+      const target = cds.model.definitions[extension.extend]
+      const dbEntity = _resolveViews(target).name
+      await _handleDefaults(extension, dbEntity, req, cds, draft)
+    }
+
+    setTimeout(() => process.send('restart'), 1111)
+  })
+}

package/libx/_runtime/fiori/uiflex/handler/transformREAD.js

@@ -0,0 +1,119 @@
+const { EXT_BACK_PACK, getExtendedFields, hasExtendedEntity, isExtendedEntity, getTargetRead } = require('../utils')
+
+const _addBackPack = (columns, extFields, alias) => {
+  if (!columns) return
+
+  const hasBackPack = columns.some(
+    col => col.ref && col.ref[col.ref.length - 1] === EXT_BACK_PACK && _hasAlias(col.ref, alias)
+  )
+  if (hasBackPack) return // get out early, avoiding overhead of second check
+
+  const hasExtFields = columns.some(
+    col => col.ref && extFields.includes(col.ref[col.ref.length - 1]) && _hasAlias(col.ref, alias)
+  )
+
+  if (hasExtFields) {
+    const col = { ref: [EXT_BACK_PACK] }
+    if (alias) col.ref.unshift(alias)
+    columns.push(col)
+  }
+
+  /*
+    Removing backpack if not needed doesn't work. Probably ref copy problem.
+    if (hasBackPack && !hasExtFields) remove backpack.
+  */
+}
+
+const _hasAlias = (ref, alias) => {
+  return (ref.length === 1 && !alias) || (ref.length > 1 && ref[0] === alias)
+}
+
+const _removeExtendedFields = (columns, extFields, alias) => {
+  if (!columns) return
+
+  let i = columns.length
+  while (i--) {
+    const col = columns[i]
+    if (col.ref && extFields.includes(col.ref[col.ref.length - 1]) && _hasAlias(col.ref, alias)) {
+      columns.splice(i, 1)
+    }
+  }
+}
+
+const _transformUnion = (req, model) => {
+  // second element is active entity
+  const name = req.target.name.SET ? req.target.name.SET.args[1]._target.name : req.target.name
+  const extFields = getExtendedFields(name, model)
+  _addBackPack(req.query.SELECT.columns, extFields)
+  _removeExtendedFields(req.query.SELECT.columns, extFields)
+
+  _addBackPack(
+    req.query.SELECT.from.SET.args[0].SELECT.columns,
+    extFields,
+    req.query.SELECT.from.SET.args[0].SELECT.from.args[0].as
+  )
+  _addBackPack(req.query.SELECT.from.SET.args[1].SELECT.columns, extFields)
+  _removeExtendedFields(
+    req.query.SELECT.from.SET.args[0].SELECT.columns,
+    extFields,
+    req.query.SELECT.from.SET.args[0].SELECT.from.args[0].as
+  )
+  _removeExtendedFields(req.query.SELECT.from.SET.args[1].SELECT.columns, extFields)
+}
+
+const _getAliasedEntitiesForJoin = (args, model) => {
+  const extEntities = []
+
+  args.forEach(arg => {
+    if (arg.ref && arg.ref[0] !== 'DRAFT.DraftAdministativeData' && isExtendedEntity(arg.ref[0], model)) {
+      const extFields = getExtendedFields(arg.ref[0], model)
+      extEntities.push({ name: arg.ref[0], as: arg.as, extFields })
+    }
+
+    if (arg.join) {
+      extEntities.push(..._getAliasedEntitiesForJoin(arg.args, model))
+    }
+  })
+
+  return extEntities
+}
+
+const _transformJoin = (req, model) => {
+  const extEntities = _getAliasedEntitiesForJoin(req.query.SELECT.from.args, model)
+
+  extEntities.forEach(ext => {
+    _addBackPack(req.query.SELECT.columns, ext.extFields, ext.as)
+    _removeExtendedFields(req.query.SELECT.columns, ext.extFields, ext.as)
+  })
+}
+
+const _transformColumns = (columns, targetName, model) => {
+  if (!columns) return
+
+  const extFields = getExtendedFields(targetName, model)
+  if (extFields.length !== 0) {
+    _addBackPack(columns, extFields)
+    _removeExtendedFields(columns, extFields)
+  }
+
+  columns.forEach(col => {
+    if (col.ref && col.expand) {
+      const expTargetName = model.definitions[targetName].elements[col.ref[0]].target
+      _transformColumns(col.expand, expTargetName, model)
+    }
+  })
+}
+
+function transformExtendedFieldsREAD(req) {
+  if (!hasExtendedEntity(req, this.model)) return
+
+  const target = getTargetRead(req)
+  _transformColumns(req.query.SELECT.columns, target.name, this.model)
+
+  if (req.query.SELECT.from.SET) return _transformUnion(req, this.model) // union
+  if (req.query.SELECT.from.join) return _transformJoin(req, this.model) // join
+}
+
+module.exports = {
+  transformExtendedFieldsREAD
+}

package/libx/_runtime/fiori/uiflex/handler/transformRESULT.js

@@ -0,0 +1,43 @@
+const { EXT_BACK_PACK, hasExtendedEntity, getTargetRead } = 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[EXT_BACK_PACK]) {
+    const extensions = JSON.parse(row[EXT_BACK_PACK])
+    Object.keys(extensions).forEach(field => {
+      row[field] = extensions[field]
+    })
+
+    delete row[EXT_BACK_PACK]
+  }
+
+  if (row[key] === undefined) {
+    row[key] = null
+  }
+}
+
+function transformExtendedFieldsRESULT(result, req) {
+  if (!result || !hasExtendedEntity(req, this.model)) return
+
+  const template = getTemplate('transform-result', this, getTargetRead(req), {
+    pick: _pick
+  })
+
+  if (template.elements.size > 0) {
+    const result_ = Array.isArray(result) ? result : [result]
+    for (const row of result_) {
+      const args = { processFn: _processorFn, row, template }
+      templateProcessor(args)
+    }
+  }
+}
+
+module.exports = {
+  transformExtendedFieldsRESULT
+}

package/libx/_runtime/fiori/uiflex/handler/transformWRITE.js

@@ -0,0 +1,62 @@
+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.target) return
+
+  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/fiori/uiflex/index.js

@@ -0,0 +1,35 @@
+module.exports = async () => {
+  const cds = require('../../cds')
+  if (!cds.requires.db) return
+
+  const db = await cds.connect.to({ ...cds.requires.db, model: null, silent: true })
+  const rs = await db.read('cds_r.Extensions')
+  if (rs.length !== 0) {
+    const extensions = []
+    rs.forEach(row => extensions.push(...JSON.parse(row.csn).extensions))
+    cds.once('loaded', csn => {
+      if (cds.model) return // extend cds.model only
+      const extended = cds.compile({
+        'base.csn': cds.compile.to.json(csn),
+        'ext.csn': cds.compile.to.json({ extensions })
+      })
+      csn.definitions = extended.definitions
+    })
+  }
+  await db.disconnect()
+
+  if (cds.db) return // because of tests
+  cds.once('served', () => {
+    const { transformExtendedFieldsCREATE, transformExtendedFieldsUPDATE } = require('./handler/transformWRITE')
+    const { transformExtendedFieldsREAD } = require('./handler/transformREAD')
+    const { transformExtendedFieldsRESULT } = require('./handler/transformRESULT')
+    cds.db
+      .before('CREATE', transformExtendedFieldsCREATE)
+      .before('UPDATE', transformExtendedFieldsUPDATE)
+      .before('READ', transformExtendedFieldsREAD)
+      .after('READ', transformExtendedFieldsRESULT)
+    if ('cds_r.ExtensibilityService' in cds.services) return
+    const model = require('path').join(__dirname, 'extensibility')
+    return cds.serve(model, { silent: true }).to('odata').in(cds.app)
+  })
+}