@sap/cds 6.0.4 → 6.1.2

package/libx/_runtime/common/perf/index.js

@@ -4,21 +4,16 @@ const _statisticsRequested = req =>
   (req.query && req.query['sap-statistics'] === 'true') ||
   (req.headers && req.headers['sap-statistics'] === 'true' && (!req.query || !req.query['sap-statistics']))
 
-module.exports = app => {
-  if (app._perf_measured) return
-  else app._perf_measured = true
+module.exports = function sap_statistics(req, res, next) {
+  if (!_statisticsRequested(req)) return next()
 
-  app.use((req, res, next) => {
-    if (!_statisticsRequested(req)) return next()
+  const t0 = performance.now()
+  const { writeHead } = res
+  res.writeHead = function (...args) {
+    const total = Number((performance.now() - t0) / 1000).toFixed(2)
+    if (res.statusCode < 400) res.setHeader('sap-statistics', `total=${total}`)
+    writeHead.call(this, ...args)
+  }
 
-    const t0 = performance.now()
-    const { writeHead } = res
-    res.writeHead = function (...args) {
-      const total = Number((performance.now() - t0) / 1000).toFixed(2)
-      if (res.statusCode < 400) res.setHeader('sap-statistics', `total=${total}`)
-      writeHead.call(this, ...args)
-    }
-
-    next()
-  })
+  next()
 }

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

@@ -1,8 +1,6 @@
 const getTemplate = require('./template')
 const templateProcessor = require('./templateProcessor')
 
-const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}={0,1}|[A-Za-z0-9+/]{2}={0,2})$/
-
 // convert the standard base64 encoding to the URL-safe variant
 const toBase64url = value =>
   (Buffer.isBuffer(value) ? value.toString('base64') : value).replace(/\//g, '_').replace(/\+/g, '-')
@@ -17,12 +15,13 @@ const isInvalidBase64string = value => {
   if (Buffer.isBuffer(value)) return // ok
 
   // convert to standard base64 string; let it crash if typeof value !== 'string'
-  const base64 = value.replace(/_/g, '/').replace(/-/g, '+')
+  const base64value = value.replace(/_/g, '/').replace(/-/g, '+')
   const normalized = normalizeBase64string(value)
 
   // example of invalid base64 string --> 'WTGTdDsD/k21LnFRb+uNcAi=' <-- '...i=' must be '...g='
   // see https://datatracker.ietf.org/doc/html/rfc4648#section-4
-  return !base64.match(BASE64) || base64.replace(/=/g, '') !== normalized.replace(/=/g, '')
+  if (base64value.replace(/=/g, '') !== normalized.replace(/=/g, '')) return true
+  return base64value.length > normalized.length
 }
 
 const _picker = element => {

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

@@ -698,7 +698,6 @@ const _convertToOneEqNullInFilter = (query, target) => {
     }
   }
 }
-
 // eslint-disable-next-line complexity
 const _convertSelect = (query, model, _options) => {
   const _4db = _options.service instanceof cds.DatabaseService

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

@@ -1,25 +1,28 @@
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
 
-const traverseFroms = (cqn, cb) => {
+const traverseFroms = (cqn, cb, aliasForSet) => {
   while (cqn.SELECT) cqn = cqn.SELECT.from
 
   // Do the most likely first -> {ref}
   if (cqn.ref) {
-    return cb(cqn)
+    return cb(cqn, aliasForSet)
   }
 
   if (cqn.SET) {
-    return cqn.SET.args.map(a => traverseFroms(a, cb))
+    // if a union has an alias, we should use it for the columns we get out of the union
+    return cqn.SET.args.map(a => traverseFroms(a, cb, cqn.as))
   }
 
   if (cqn.join) {
-    return cqn.args.map(a => traverseFroms(a, cb))
+    return cqn.args.map(a => traverseFroms(a, cb, aliasForSet))
   }
 }
 
 const getEntityNameFromCQN = cqn => {
   const res = []
-  traverseFroms(cqn, from => res.push({ entityName: from.ref[0].id || from.ref[0], alias: from.as }))
+  traverseFroms(cqn, (from, aliasForSet) =>
+    res.push({ entityName: from.ref[0].id || from.ref[0], alias: aliasForSet || from.as })
+  )
   return res.length === 1 ? res[0] : res.find(n => n.entityName !== 'DRAFT.DraftAdministrativeData') || {}
 }
 

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

@@ -27,13 +27,18 @@ function _getOnCondElements(onCond, onCondElements = []) {
   return onCondElements
 }
 
-function _modifyWhereWithNavigations(where, newWhere, entityKey, targetKey) {
-  if (where) {
+function _mergeWhere(base, additional) {
+  if (additional?.length) {
     // copy where else query will be modified
-    const whereCopy = deepCopyArray(where)
-    if (newWhere.length > 0) newWhere.push('and')
-    newWhere.push(...whereCopy)
+    const whereCopy = deepCopyArray(additional)
+    if (base.length > 0) base.push('and')
+    base.push(...whereCopy)
   }
+  return base
+}
+
+function _modifyWhereWithNavigations(where, newWhere, entityKey, targetKey) {
+  _mergeWhere(newWhere, where)
 
   newWhere.forEach(element => {
     if (element.ref && element.ref[0] === targetKey) {
@@ -85,7 +90,10 @@ function _getWhereFromUpdate(query, target, model) {
     return where
   }
 
-  return query.UPDATE.where
+  const where = query.UPDATE.where || []
+  if (query.UPDATE.entity.ref?.length === 1 && query.UPDATE.entity.ref[0].where)
+    return _mergeWhere(query.UPDATE.entity.ref[0].where, where)
+  return where
 }
 
 // params: data, req, service/tx

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

@@ -612,7 +612,7 @@ const _newQuery = (query, event, model, service) => {
   }[event]
   const newQuery = Object.create(query)
   const transitions = _entityTransitionsForTarget(query[event][_prop], model, service)
-  newQuery[event] = (transitions[0] && _func(newQuery, transitions, service)) || { ...query[event] }
+  newQuery[event] = (transitions?.[0] && _func(newQuery, transitions, service)) || { ...query[event] }
   return newQuery
 }
 

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

@@ -134,7 +134,7 @@ const getCache = (anything, cache, newCacheFn) => {
 }
 
 module.exports = (usecase, tx, target, ...args) => {
-  // get model first as it may be added to tx (cf. "_ensureModel")
+  // get model first as it may be added to tx (cf. "_ensureModel") // REVISIT: _ensureModel is gone
   const model = tx.model
   if (!model) return
 

package/libx/_runtime/db/Service.js

@@ -24,28 +24,16 @@ class DatabaseService extends cds.Service {
       this[`_${each}`] = generic[each]
     }
 
-    // REVISIT: ensures tenant-aware this.model if this is a transaction -> this should be fixed in mtx integration, not here
-    this._ensureModel = function (req) {
-      if (this.context) {
-        // if the tx was initiated in messaging, then this.context._model is not unfolded
-        //   -> use this.context._model._4odata if present
-        const { _model } = this.context
-        if (_model) this.model = _model._4odata || _model
-        else this.model = req._model
-      }
-    }
-    this._ensureModel._initial = true
-
     // REVISIT: how to generic handler registration?
   }
 
   /** Database services don't support custom-defined operations */
-  operations() {
+  get operations() {
     return []
   }
 
   /** Database services don't support custom-defined events */
-  events() {
+  get events() {
     return []
   }
 

package/libx/_runtime/db/expand/expandCQNToJoin.js

@@ -12,6 +12,8 @@ const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
 const { filterKeys } = require('../../fiori/utils/handler')
 
+const getError = require('../../common/error')
+
 // Symbols are used to add extra information in response structure
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
 const TO_MANY = Symbol.for('sap.cds.toMany')
@@ -94,6 +96,16 @@ class JoinCQNFromExpanded {
     return this._isDraft
   }
 
+  // There can be a limit/offset for the target entity.
+  // The current expand implementation applys a `DISTINCT` on
+  // `filterExpand`, which changes the sorting in absence of `ORDER BY`.
+  // Therefore, add an implicit `ORDER BY` in those cases.
+  _addImplicitOrderBy(cqn, entity, alias) {
+    if (cqn.orderBy || !cqn.limit || !entity) return // not needed
+    const orderByColumns = cqn.groupBy || getAllKeys(entity).map(key => ({ ref: [alias, key] }))
+    cqn.orderBy = orderByColumns
+  }
+
   /**
    * Build first level of expanding regarding to many and all to one if not part of a nested to many expand.
    *
@@ -123,6 +135,7 @@ class JoinCQNFromExpanded {
         })
       // expand to one
       const entity = this._csn.definitions[joinArgs[0].SELECT.from.SET.args[1].SELECT.from.ref[0]]
+      this._addImplicitOrderBy(readToOneCQN, entity, tableAlias)
       const givenColumns = readToOneCQN.columns
       readToOneCQN.columns = []
       this._expandedToFlat({ entity, givenColumns, readToOneCQN, tableAlias, toManyTree, defaultLanguage })
@@ -130,7 +143,7 @@ class JoinCQNFromExpanded {
       const table = unionTable || this._getRef(SELECT).table
       const isDraftTree = this._isDraftTree(table)
       const entity = this._getEntityForTable(table)
-
+      this._addImplicitOrderBy(readToOneCQN, entity, tableAlias)
       if (unionTable) readToOneCQN[IS_UNION_DRAFT] = true
 
       readToOneCQN[IS_ACTIVE] = isDraftTree ? this._isDraftTargetActive(table) : true
@@ -455,14 +468,10 @@ class JoinCQNFromExpanded {
 
     if (element.ref) {
       element.ref[1] = Object.assign({}, element.ref[1])
-      element.ref[1].args = element.ref[1].args.map(arg => {
-        return this._mapArg(arg, cqn, tableAlias)
-      })
+      element.ref[1].args = element.ref[1].args.map(arg => this._mapArg(arg, cqn, tableAlias))
     } else {
       element.args = element.args.slice(0)
-      element.args = element.args.map(arg => {
-        return this._mapArg(arg, cqn, tableAlias)
-      })
+      element.args = element.args.map(arg => this._mapArg(arg, cqn, tableAlias))
     }
   }
 
@@ -684,6 +693,17 @@ class JoinCQNFromExpanded {
         c => !expandedEntity.keys[c].isAssociation && !(c in DRAFT_COLUMNS_MAP)
       )
       const user = (cds.context && cds.context.user && cds.context.user.id) || 'anonymous'
+
+      const assoc = entity.associations[column.ref[0]]
+      if (assoc.is2one && assoc.on) {
+        const onCond = entity._relations[assoc.name].join('target', 'source')
+        const xpr = onCond[0].xpr
+        const fks = (xpr && xpr.filter(e => e.ref && e.ref[0] === 'target').map(e => e.ref[1])) || []
+        for (const k of fks) {
+          if (!cols.includes(k)) cols.push(k)
+        }
+      }
+
       const unionFrom = getCQNUnionFrom(cols, expandedEntity.name, expandedEntity.name + '.drafts', ks, user)
       readToOneCQN.from.args[1] = {
         SELECT: {
@@ -1162,7 +1182,7 @@ class JoinCQNFromExpanded {
       cqn.orderBy = this._copyOrderBy(column.orderBy, tableAlias, expandedEntity)
     }
 
-    if (column.limit) cqn.limit = column.limit
+    if (column.limit) throw getError(501, 'Pagination is not supported in expand')
 
     cqn = this._adaptWhereOrderBy(cqn, tableAlias)
 
@@ -1227,23 +1247,6 @@ class JoinCQNFromExpanded {
     return assoc.target + '_drafts'
   }
 
-  _getLimitInSelect(cqn, columns, limit, orderBy, expandedEntity) {
-    const select = {
-      SELECT: {
-        columns: this._copyColumns(columns, 'limitFilter'),
-        from: { ref: [cqn.from.args[0].ref[0]], as: 'limitFilter' },
-        where: this._convertOnToWhere(cqn.from.on, cqn.from.args[0].as, 'limitFilter'),
-        limit: limit
-      }
-    }
-
-    if (orderBy) {
-      select.SELECT.orderBy = this._copyOrderBy(orderBy, 'limitFilter', expandedEntity)
-    }
-
-    return select
-  }
-
   _isPathExpressionToOne(ref, entity) {
     const ref0 = ref[0]
     const el = entity.elements[ref0]

package/libx/_runtime/db/expand/rawToExpanded.js

@@ -30,9 +30,13 @@ class RawToExpanded {
       if (each._conversionMapper) for (const [k, v] of [...each._conversionMapper]) conversionMapper.set(k, v)
     }
 
-    for (let i = 0, length = this._queries.length; i < length; i++) {
+    const queryResults = await Promise.all(this._queries)
+    // NOTE: this doesn't work:
+    // for (let each of this._queries) await each
+
+    for (let i = 0, length = queryResults.length; i < length; i++) {
       const { _toManyTree: toManyTree = [] } = queries[i]
-      const result = await this._queries[i]
+      const result = queryResults[i]
       if (toManyTree.length === 0) {
         this._parseMainResult(result, mappings, conversionMapper, toManyTree)
       } else {
@@ -249,10 +253,7 @@ class RawToExpanded {
  * @returns {Promise<Array>} The complete expanded result set.
  */
 const rawToExpanded = (configs, queries, one, rootEntity) => {
-  return new RawToExpanded(configs, queries, one, rootEntity).toExpanded().catch(err => {
-    Promise.all(queries).catch(() => {})
-    throw err
-  })
+  return new RawToExpanded(configs, queries, one, rootEntity).toExpanded()
 }
 
 module.exports = rawToExpanded

package/libx/_runtime/db/generic/input.js

@@ -176,7 +176,14 @@ const _pickDraft = element => {
   // collect actions to apply
   const categories = []
 
-  if (element.virtual) categories.push('virtual')
+  if (_isVirtualOrCalculated(element)) {
+    categories.push('virtual')
+    return { categories } // > no need to continue
+  }
+
+  if (element.default && !DRAFT_COLUMNS_MAP[element.name]) {
+    categories.push({ category: 'default', args: element })
+  }
 
   // REVISIT: element._foreignKeys.length seems to be a very broad check
   if (element.isAssociation && element._foreignKeys.length) {

package/libx/_runtime/db/sql-builder/InsertBuilder.js

@@ -306,7 +306,7 @@ class InsertBuilder extends BaseBuilder {
     const purelyManagedColumnValues = this._getAnnotatedInsertColumnValues(annotatedColumns, purelyManagedColumns)
 
     this._addUuidToColumns(columns, flattenColumnMap)
-    columns.push(...flattenColumnMap.keys())
+    columns.push(...Array.from(flattenColumnMap.keys()).filter(k => !columns.includes(k)))
 
     this._addEntries(valuesArray, { columns, flattenColumnMap, purelyManagedColumnValues, insertAnnotatedColumns })
 

package/libx/_runtime/db/sql-builder/SelectBuilder.js

@@ -98,9 +98,7 @@ class SelectBuilder extends BaseBuilder {
       this._orderBy(noQuoting)
     }
 
-    if (this._obj.SELECT.limit || this._obj.SELECT.one) {
-      this._limit()
-    }
+    this._limit()
 
     if (this._obj.SELECT.forUpdate) {
       this._forUpdate()
@@ -322,11 +320,8 @@ class SelectBuilder extends BaseBuilder {
 
   _where() {
     const entityName = this._obj.SELECT.from.ref && this._obj.SELECT.from.ref[0]
-    const where = new this.ExpressionBuilder(
-      this._obj.SELECT.where,
-      entityName ? { ...this._options, entityName } : this._options,
-      this._csn
-    ).build()
+    const options = entityName ? { ...this._options, entityName } : this._options
+    const where = new this.ExpressionBuilder(this._obj.SELECT.where, options, this._csn).build()
     this._outputObj.sql.push('WHERE', where.sql)
     this._outputObj.values.push(...where.values)
   }
@@ -415,6 +410,34 @@ class SelectBuilder extends BaseBuilder {
     this._outputObj.sql.push(sqls.join(', '))
   }
 
+  _addRows() {
+    if (this._obj.SELECT.limit) {
+      if (this._obj.SELECT.limit.rows !== undefined) {
+        // limit (no placeholder for statement caching)
+        this._outputObj.sql.push('LIMIT', this._obj.SELECT.limit.rows.val)
+      } else {
+        // rows parameter is mandatory for SQL
+        throw new Error('Rows parameter is missing in SELECT.limit(rows, offset)')
+      }
+    }
+  }
+
+  _addOne() {
+    this._outputObj.sql.push('LIMIT', 1)
+  }
+
+  _addOffset() {
+    // offset
+    if (this._obj.SELECT.limit && this._obj.SELECT.limit.offset !== undefined) {
+      if (typeof this._obj.SELECT.limit.offset.val === 'number' && !this._parameterizedNumbers) {
+        this._outputObj.sql.push('OFFSET', this._obj.SELECT.limit.offset.val)
+      } else {
+        this._outputObj.sql.push('OFFSET', '?')
+        this._outputObj.values.push(this._obj.SELECT.limit.offset.val)
+      }
+    }
+  }
+
   /**
    * sql limit clause will be generated without placeholders.
    * reason is optimizing paging queries. number of rows does not change.
@@ -423,17 +446,13 @@ class SelectBuilder extends BaseBuilder {
    * offset will still use placeholders, as it'll change during the paging queries.
    */
   _limit() {
-    // limit (no placeholder for statement caching)
-    this._outputObj.sql.push('LIMIT', this._obj.SELECT.one ? 1 : this._obj.SELECT.limit.rows.val)
-    // offset
-    if (this._obj.SELECT.limit && this._obj.SELECT.limit.offset) {
-      if (typeof this._obj.SELECT.limit.offset.val === 'number' && !this._parameterizedNumbers) {
-        this._outputObj.sql.push('OFFSET', this._obj.SELECT.limit.offset.val)
-      } else {
-        this._outputObj.sql.push('OFFSET', '?')
-        this._outputObj.values.push(this._obj.SELECT.limit.offset.val)
-      }
+    if (this._obj.SELECT.one) {
+      this._addOne()
+    } else {
+      this._addRows()
     }
+
+    this._addOffset()
   }
 
   _parameters() {

package/libx/_runtime/extensibility/activate.js

@@ -1,69 +1,69 @@
 const cds = require('../cds')
 
 const handleDefaults = require('./defaults')
+const Extensions = 'cds.xt.Extensions'
 
-const _calculateExtensions = async function (ID, tag, tenant) {
+// REVISIT: Reuse ratio = 0
+const _calculateExtensions = async function (ID, tag) {
   let active, inactive
-  await cds.tx({ tenant }, async tx => {
-    if (tag || ID) {
-      const inactiveCqn = SELECT.from('cds.xt.Extensions').where({ activated: 'propertyBag' })
-      if (ID) {
-        inactiveCqn.where('ID !=', ID)
-      } else {
-        inactiveCqn.where('tag !=', tag)
-      }
-      inactive = await tx.run(inactiveCqn)
-      const activeCqn = SELECT.from('cds.xt.Extensions').where({ activated: 'database' })
-      if (ID) {
-        activeCqn.or({ ID })
-      } else {
-        if (tag) activeCqn.or({ tag })
-      }
-      active = await tx.run(activeCqn)
-      if (inactive.length) {
-        const deleteCqn = DELETE.from('cds.xt.Extensions').where(inactiveCqn.SELECT.where)
-        await tx.run(deleteCqn)
-      }
+  if (tag || ID) {
+    const inactiveCqn = SELECT.from(Extensions).where({ activated: 'propertyBag' })
+    if (ID) {
+      inactiveCqn.where('ID !=', ID)
     } else {
-      // activate all
-      inactive = []
-      active = await tx.run(SELECT.from('cds.xt.Extensions'))
+      inactiveCqn.where('(tag !=', tag, 'or tag =', null, ')')
     }
-  })
+    inactive = await cds.db.run(inactiveCqn)
+    const activeCqn = SELECT.from(Extensions).where({ activated: 'database' })
+    if (ID) {
+      activeCqn.or({ ID })
+    } else if (tag) {
+      activeCqn.or({ tag })
+    }
+    active = await cds.db.run(activeCqn)
+    if (inactive.length) {
+      const deleteCqn = DELETE.from(Extensions).where(inactiveCqn.SELECT.where)
+      await cds.db.run(deleteCqn)
+    }
+  } else {
+    // activate all
+    inactive = []
+    active = await cds.db.run(SELECT.from(Extensions))
+  }
 
   return { active, inactive }
 }
 
-const _restoreExtensions = async function (tenant, active, inactive) {
-  await cds.tx({ tenant }, async tx => {
-    // delete all extensions
-    await tx.run(DELETE.from('cds.xt.Extensions'))
-    // active
-    active.forEach(row => {
-      row.csn = row.csn.replace(/,"@cds.extension":true/g, '')
-      row.activated = 'database'
-      row.timestamp = '$now'
-    })
-    await tx.run(INSERT.into('cds.xt.Extensions').entries(active))
-    // inactive
-    if (inactive.length) {
-      for (const na of inactive) {
-        for (const extension of JSON.parse(na.csn).extensions) {
-          await handleDefaults(extension, tx)
-        }
+// REVISIT: Reuse ratio = 0
+const _restoreExtensions = async function (active, inactive, appCsn) {
+  // delete all extensions
+  await cds.db.run(DELETE.from(Extensions))
+  // active
+  active.forEach(row => {
+    row.csn = row.csn.replace(/,"@cds.extension":true/g, '')
+    row.activated = 'database'
+    row.timestamp = '$now'
+  })
+  await cds.db.run(INSERT.into(Extensions).entries(active))
+  // inactive
+  if (inactive.length) {
+    for (const na of inactive) {
+      for (const extension of JSON.parse(na.csn).extensions) {
+        await handleDefaults(extension, appCsn, cds.db)
       }
-      await tx.run(INSERT.into('cds.xt.Extensions').entries(inactive))
     }
-  })
+    await cds.db.run(INSERT.into(Extensions).entries(inactive))
+  }
 }
 
-const activate = async function (ID, tag, tenant) {
-  const { active, inactive } = await _calculateExtensions(ID, tag, tenant)
+// REVISIT: Review with Vitaly: (1) Delete Inactives > (2) DS.extend(t) > (3) Delete All > (4) Restore All ???
+const activate = async function (ID, tag, tenant, appCsn) {
+  const { active, inactive } = await _calculateExtensions(ID, tag)
 
   const { 'cds.xt.DeploymentService': ds } = cds.services
   await ds.extend(tenant)
 
-  await _restoreExtensions(tenant, active, inactive)
+  await _restoreExtensions(active, inactive, appCsn)
 }
 
 module.exports = activate

package/libx/_runtime/extensibility/add.js

@@ -1,4 +1,5 @@
 const cds = require('../cds')
+const LOG = cds.log('mtx')
 
 const { validateExtension } = require('./validation')
 const handleDefaults = require('./defaults')
@@ -11,21 +12,26 @@ const add = async function (req) {
   if (!extension || !extension.length) req.reject(400, 'Missing extension')
   if (!activate) activate = 'database'
   if (!tag) tag = null
-  const tenant = req.tenant || (req.user.is('internal-user') && req.data.tenant)
+  const tenant = (req.user.is('internal-user') && req.data.tenant) || req.tenant
 
-  const csn = _isCSN(extension) ? JSON.parse(extension) : cds.parse.cdl(extension)
-  if (csn.requires) delete csn.requires
-  await validateExtension(csn, tenant, req)
+  const extCsn = _isCSN(extension) ? JSON.parse(extension) : cds.parse.cdl(extension)
+  if (extCsn.requires) delete extCsn.requires
 
+  LOG.info(`validating extension '${tag}' ...`)
+  const { 'cds.xt.ModelProviderService': mps } = cds.services
+  const csn = await mps.getCsn(tenant, ['*'])
+  validateExtension(extCsn, csn, req)
+
+  if (tenant) cds.context = { tenant }
   const ID = cds.utils.uuid()
-  await cds.tx({ tenant }, async tx => {
-    await tx.run(INSERT.into('cds.xt.Extensions').entries([{ ID, tag, csn: JSON.stringify(csn), activated: activate }]))
-    if (activate === 'propertyBag' && csn.extensions) csn.extensions.forEach(async ext => await handleDefaults(ext, tx))
-  })
-
-  if (activate === 'database') {
-    await activateExt(ID, tag, tenant)
-  }
+  await cds.db.run(
+    INSERT.into('cds.xt.Extensions').entries([{ ID, tag, csn: JSON.stringify(extCsn), activated: activate }])
+  )
+  const njCsn = cds.compile.for.nodejs(csn)
+  LOG.info(`activating extension to '${activate}' ...`)
+  if (activate === 'propertyBag' && extCsn.extensions)
+    extCsn.extensions.forEach(async ext => await handleDefaults(ext, njCsn))
+  if (activate === 'database') await activateExt(ID, tag, tenant, njCsn)
 }
 
 const promote = async function (req) {
@@ -35,7 +41,10 @@ const promote = async function (req) {
   const tenant = req.tenant || (req.user.is('internal-user') && req.data.tenant) || ''
   if (activate !== 'database') req.reject(400, 'Promote to propertyBag is not supported')
 
-  await activateExt(null, tag, tenant)
+  const { 'cds.xt.ModelProviderService': mps } = cds.services
+  const njCsn = await mps.getCsn(tenant, ['*'], 'nodejs')
+  if (tenant) cds.context = { tenant }
+  await activateExt(null, tag, tenant, njCsn)
 }
 
 module.exports = { add, promote }