@sap/cds 6.0.2 → 6.1.0

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

@@ -178,6 +178,10 @@ const _pickDraft = element => {
 
   if (element.virtual) categories.push('virtual')
 
+  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) {
     categories.push({ category: 'propagateForeignKeys' })

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

@@ -11,21 +11,24 @@ 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
 
+  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)
+  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 +38,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 }

package/libx/_runtime/extensibility/addExtension.js

@@ -18,9 +18,9 @@ const _addAnnotation = extension => {
   })
 }
 
-const _addViews = csn => {
+const _addViews = (csn, appCsn) => {
   csn.extensions.forEach(extension => {
-    const target = cds.model.definitions[extension.extend]
+    const target = appCsn.definitions[extension.extend]
     const views_ = []
     const view = resolveViews(target, views_)
     extension.extend = view && view.name
@@ -41,28 +41,32 @@ const _addViews = csn => {
   })
 }
 
-const _addExtension = async function (csn, req) {
-  const tx = cds.tx(req)
-  await tx.run(
+const _addExtension = async function (csn, appCsn, req) {
+  if (req.tenant) cds.context = { tenant: req.tenant }
+  await cds.db.run(
     INSERT.into('cds.xt.Extensions').entries([
       { ID: cds.utils.uuid(), tag: 'uiflex', csn: JSON.stringify(csn), activated: 'propertyBag' }
     ])
   )
 
-  // defaults
   for (const ext of req.data.extensions) {
     const extension = JSON.parse(ext)
-    await handleDefaults(extension, tx, false)
+    await handleDefaults(extension, appCsn, false)
   }
 }
 
 const addExtension = async function (req) {
-  const csn = _getCsn(req)
-  validateCsn(csn, req)
-  validateExtensionFields(csn, req)
-  _addViews(csn, cds)
-  await validateExtension(csn, req.tenant, req)
-  await _addExtension(csn, req)
+  const { 'cds.xt.ModelProviderService': mps } = cds.services
+  const csn = await mps.getCsn(req.tenant, ['*'])
+  const extCsn = _getCsn(req)
+  const njCsn = cds.compile.for['nodejs'](csn)
+  // REVISIT: Optimize the validations
+  // REVISIT: Why do we need njCsn?
+  validateCsn(extCsn, njCsn, req)
+  validateExtensionFields(extCsn, njCsn, req)
+  _addViews(extCsn, njCsn)
+  validateExtension(extCsn, csn, req)
+  await _addExtension(extCsn, njCsn, req)
 }
 
 module.exports = addExtension

package/libx/_runtime/extensibility/defaults.js

@@ -1,38 +1,33 @@
 const cds = require('../cds')
-
-const { ensureDraftsSuffix } = require('../common/utils/draft')
 const resolveViews = require('./views')
-const { EXT_BACK_PACK } = require('./utils')
-
-const _needsQuotations = t => t instanceof cds.builtin.classes.string || t instanceof cds.builtin.classes.date
-
-const _getDraftTable = view => {
-  return cds.model.definitions[view]._isDraftEnabled ? ensureDraftsSuffix(view) : undefined
-}
-
-const handleDefaults = async (extension, tx, checkDb = true) => {
-  const target = cds.model.definitions[extension.extend]
-  const dbEntity = resolveViews(target).name
-
-  if (checkDb && target.name !== dbEntity) return // only db entities
-
-  const draft = _getDraftTable(extension.extend)
-  const ext = Object.keys(extension.elements)
-    .filter(key => extension.elements[key].default)
+const builtin = cds.builtin.types
+const needsQuotes = Symbol()
+builtin.string[needsQuotes] = true
+builtin.date[needsQuotes] = true
+
+const handleDefaults = async (extension, { definitions }, checkDb = true) => {
+  const target = definitions[extension.extend]
+  const entity = resolveViews(target)
+  if (checkDb && target !== entity) return // only db entities
+
+  const elements = extension.elements
+  const defaults = Object.keys(elements)
+    .filter(key => elements[key].default)
     .map(key => {
-      const element = extension.elements[key]
-      // .type as ui flex extensions are not linked
-      const t = cds.model.definitions[element.type] || cds.builtin.types[element.type]
-      const value = t && _needsQuotations(t) ? `"${element.default.val}"` : element.default.val
-      return `"${key}":${value}`
+      const e = elements[key],
+        { val } = e.default
+      const t = definitions[e.type] || builtin[e.type]
+      return `"${key}":${t && t[needsQuotes] ? `"${val}"` : val}`
     })
 
-  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 tx.run(UPDATE(dbEntity).with(assign))
-    if (draft) await tx.run(UPDATE(draft).with(assign))
+  if (defaults.length) {
+    const newDefaults = defaults.join(',')
+    const newBagpack = `extensions__ = CASE
+      WHEN extensions__ is null THEN '{${newDefaults}}'
+      ELSE '{${newDefaults},' || substr(extensions__, 2, length(extensions__)-1)
+    END`
+    await Promise.all([UPDATE(entity).with(newBagpack), entity.drafts && UPDATE(entity.drafts).with(newBagpack)])
+    // NOTE: We don't need the model definitions for `entity` in cds.db.model to run these queries
   }
 }