@sap/cds 5.9.8 → 6.0.3

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

@@ -51,15 +51,6 @@ class ReferenceBuilder extends BaseBuilder {
         this._outputObj.sql.push('CAST', '(')
       }
 
-      // REVISIT: compat for legacy ref: "['foo as bar']" -> remove with cds^6
-      if (this._obj.ref.length === 1 && typeof this._obj.ref[0] === 'string') {
-        const matched = this._obj.ref[0].match(/(\S*)\s{1,}as\s{1,}(\S*)/i)
-        if (matched) {
-          this._obj.ref = [matched[1]]
-          this._obj.as = matched[2].replace(/^"/, '').replace(/"$/, '')
-        }
-      }
-
       if (this._obj.param) {
         this._parseParamReference(this._obj.ref)
       } else {

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

@@ -1,5 +1,3 @@
-const cds = require('../../cds')
-
 const BaseBuilder = require('./BaseBuilder')
 const { DRAFT_COLUMNS_MAP } = require('../../common/constants/draft')
 
@@ -108,6 +106,10 @@ class SelectBuilder extends BaseBuilder {
       this._forUpdate()
     }
 
+    if (this._obj.SELECT.forShareLock) {
+      this._forShareLock()
+    }
+
     this._parameters()
     this._outputObj.sql = /** @type {string} */ this._outputObj.sql.join(' ')
     return this._outputObj
@@ -133,6 +135,10 @@ class SelectBuilder extends BaseBuilder {
     }
   }
 
+  _forShareLock() {
+    this._outputObj.sql.push('FOR SHARE LOCK')
+  }
+
   _distinct() {
     this._outputObj.sql.push('DISTINCT')
   }
@@ -268,7 +274,7 @@ class SelectBuilder extends BaseBuilder {
   }
 
   // this function is overridden in hana in CustomSelectBuilder
-  _buildRefElement(col, res, noQuoting) {
+  _buildRefElement(col, res) {
     res = new this.ReferenceBuilder(col, this._options, this._csn).build()
     return res
   }
@@ -281,7 +287,7 @@ class SelectBuilder extends BaseBuilder {
     ) {
       // REVISIT: db cleanup
       // slugify is needed for a unit test. Really required in production?
-      const slugifiedAlias = col.as.replace(/\./g, '_')
+      const slugifiedAlias = col.as.includes('@odata.') ? col.as : col.as.replace(/\./g, '_')
       return ` AS ${this._quote(slugifiedAlias)}`
     }
 
@@ -439,13 +445,8 @@ class SelectBuilder extends BaseBuilder {
   }
 
   _val(obj) {
-    let _val = obj.val
+    const _val = obj.val
     if (typeof _val === 'number' || _val === null) return { sql: _val, values: [] }
-    // REVISIT: remove with cds^6
-    if (typeof _val === 'string' && cds.env.features.extract_vals !== false) {
-      const match = _val.match(/^'(.*)'$/)
-      if (match) _val = match[1]
-    }
     return { sql: '?', values: [_val] }
   }
 

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

@@ -119,7 +119,7 @@ class UpdateBuilder extends BaseBuilder {
       })
     }
 
-    resMap.forEach((value, key, map) => {
+    resMap.forEach((value, key) => {
       if (value && value.sql) {
         sql.push(`${this._quoteElement(key)} = ${value.sql}`)
         this._outputObj.values.push(...value.values)
@@ -192,7 +192,7 @@ class UpdateBuilder extends BaseBuilder {
     }
   }
 
-  _where(entityName) {
+  _where() {
     const where = new this.ExpressionBuilder(this._obj.UPDATE.where, this._options, this._csn).build()
     this._outputObj.sql.push('WHERE', where.sql)
     this._outputObj.values = this._outputObj.values.concat(where.values)

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

@@ -1,6 +1,5 @@
 const getColumns = require('../utils/columns')
-//  REVISIT: Remove support for @odata.on... with @sap/cds ^6
-const ANNOTATIONS = ['@cds.on.insert', '@odata.on.insert', '@cds.on.update', '@odata.on.update']
+const ANNOTATIONS = ['@cds.on.insert', '@cds.on.update']
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
 
 const _getAnnotationNames = column => {

package/libx/_runtime/db/utils/coloredTxCommands.js

@@ -0,0 +1,5 @@
+module.exports = {
+  BEGIN: '\x1b[1m\x1b[33mBEGIN\x1b[0m',
+  COMMIT: '\x1b[1m\x1b[32mCOMMIT\x1b[0m',
+  ROLLBACK: '\x1b[1m\x1b[91mROLLBACK\x1b[0m'
+}

package/libx/_runtime/db/utils/columns.js

@@ -23,7 +23,7 @@ const getColumns = (entity, { _4db, onlyKeys } = { _4db: true, onlyKeys: false }
     if (element.isAssociation) continue
     if (_4db && entity._isDraftEnabled && elementName in DRAFT_COLUMNS_MAP) continue
     if ((cds.env.effective.odata.structs || cds.env.features.ucsn_struct_conversion) && element.elements) {
-      columnNames.push(...resolveStructured({ structName: elementName, structProperties: [] }, element.elements, false))
+      columnNames.push(...resolveStructured({ element, structProperties: [] }, false))
       continue
     }
     columnNames.push(elementName)

package/libx/_runtime/db/utils/propagateForeignKeys.js

@@ -62,6 +62,14 @@ const _propagateToParent = ({ parentElement, childElement, deep }, childRow, row
 }
 
 module.exports = (tKey, row, foreignKeyPropagations, isCompositionEffective) => {
+  if (row[tKey] === null) {
+    for (const foreignKeyPropagation of foreignKeyPropagations) {
+      if (!foreignKeyPropagation.fillChild) row[foreignKeyPropagation.parentElement.name] = null
+    }
+    if (!isCompositionEffective) delete row[tKey]
+    return
+  }
+
   const childRows = Array.isArray(row[tKey]) ? row[tKey] : [row[tKey]]
 
   for (const childRow of childRows) {
@@ -74,12 +82,12 @@ module.exports = (tKey, row, foreignKeyPropagations, isCompositionEffective) =>
         if (pk && !(pk in row)) _propagateToParent(foreignKeyPropagation, childRow, row)
         if (!(pk in row)) _generateParentField(foreignKeyPropagation, row)
 
-        if (!isCompositionEffective) delete row[tKey]
-        else _propagateToChid(foreignKeyPropagation, row, childRow)
+        if (isCompositionEffective) _propagateToChid(foreignKeyPropagation, row, childRow)
       } else {
         _generateChildField(foreignKeyPropagation, childRow)
         _propagateToParent(foreignKeyPropagation, childRow, row)
       }
     }
   }
+  if (!isCompositionEffective) delete row[tKey]
 }

package/libx/_runtime/extensibility/activate.js

@@ -0,0 +1,69 @@
+const cds = require('../cds')
+
+const handleDefaults = require('./defaults')
+
+const _calculateExtensions = async function (ID, tag, tenant) {
+  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)
+      }
+    } else {
+      // activate all
+      inactive = []
+      active = await tx.run(SELECT.from('cds.xt.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)
+        }
+      }
+      await tx.run(INSERT.into('cds.xt.Extensions').entries(inactive))
+    }
+  })
+}
+
+const activate = async function (ID, tag, tenant) {
+  const { active, inactive } = await _calculateExtensions(ID, tag, tenant)
+
+  const { 'cds.xt.DeploymentService': ds } = cds.services
+  await ds.extend(tenant)
+
+  await _restoreExtensions(tenant, active, inactive)
+}
+
+module.exports = activate

package/libx/_runtime/extensibility/add.js

@@ -0,0 +1,41 @@
+const cds = require('../cds')
+
+const { validateExtension } = require('./validation')
+const handleDefaults = require('./defaults')
+const activateExt = require('./activate')
+
+const _isCSN = str => str.substring(0, 1) === '{'
+
+const add = async function (req) {
+  let { extension, tag, activate } = req.data
+  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 csn = _isCSN(extension) ? JSON.parse(extension) : cds.parse.cdl(extension)
+  if (csn.requires) delete csn.requires
+  await validateExtension(csn, tenant, req)
+
+  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)
+  }
+}
+
+const promote = async function (req) {
+  let { tag, activate } = req.data
+  if (!activate) activate = 'database'
+  if (!tag) tag = null
+  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)
+}
+
+module.exports = { add, promote }

package/libx/_runtime/extensibility/addExtension.js

@@ -0,0 +1,68 @@
+const cds = require('../cds')
+
+const { validateCsn, validateExtensionFields, validateExtension } = require('./validation')
+const handleDefaults = require('./defaults')
+const resolveViews = require('./views')
+
+const _getCsn = req => {
+  const csn = {
+    extensions: req.data.extensions.map(ext => JSON.parse(ext))
+  }
+
+  return csn
+}
+
+const _addAnnotation = extension => {
+  Object.values(extension.elements).forEach(el => {
+    el['@cds.extension'] = true
+  })
+}
+
+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 _addExtension = async function (csn, req) {
+  const tx = cds.tx(req)
+  await tx.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)
+  }
+}
+
+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)
+}
+
+module.exports = addExtension

package/libx/_runtime/extensibility/defaults.js

@@ -0,0 +1,39 @@
+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)
+    .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}`
+    })
+
+  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))
+  }
+}
+
+module.exports = handleDefaults

package/libx/_runtime/extensibility/{uiflex/handler → handler}/transformRESULT.js

@@ -1,7 +1,7 @@
 const { EXT_BACK_PACK, hasExtendedEntity, getTargetRead } = require('../utils')
 
-const getTemplate = require('../../../common/utils/template')
-const templateProcessor = require('../../../common/utils/templateProcessor')
+const getTemplate = require('../../common/utils/template')
+const templateProcessor = require('../../common/utils/templateProcessor')
 
 const _pick = element => {
   return element['@cds.extension']

package/libx/_runtime/extensibility/{uiflex/handler → handler}/transformWRITE.js

@@ -1,7 +1,7 @@
 const { EXT_BACK_PACK, getTargetWrite, isExtendedEntity } = require('../utils')
 
-const getTemplate = require('../../../common/utils/template')
-const templateProcessor = require('../../../common/utils/templateProcessor')
+const getTemplate = require('../../common/utils/template')
+const templateProcessor = require('../../common/utils/templateProcessor')
 
 const _pick = element => {
   return element['@cds.extension']

package/libx/_runtime/extensibility/push.js

@@ -0,0 +1,61 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../cds')
+
+const activate = require('./activate')
+const { validateExtension } = require('./validation')
+const { collectFiles, getCompilerError, exists } = require('./utils')
+const { packTarArchive, unpackTarArchive } = require('../../../lib/utils/resources')
+
+const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
+
+const _compileProject = async function (extension, req) {
+  let csn, root
+  try {
+    root = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}extension-`)
+    await unpackTarArchive(extension, root)
+    csn = await cds.compile(collectFiles(root, ['.cds', '.json']), { flavor: 'parsed' })
+    if (csn.requires) delete csn.requires
+  } catch (err) {
+    if (err.messages) req.reject(400, getCompilerError(err.messages))
+    else throw err
+  } finally {
+    if (await exists(root)) {
+      await (fs.promises.rm || fs.promises.rmdir)(root, { recursive: true, force: true })
+    }
+  }
+
+  return csn
+}
+
+const base = async function (req) {
+  const cdsFiles = cds.resolve('*').filter(f => f.startsWith(cds.root) && !f.includes('node_modules'))
+  const csvObj = await cds.deploy.resources()
+  const csvFiles = Object.keys(csvObj).filter(f => f.startsWith(cds.root) && !f.includes('node_modules'))
+  const i18nFiles = collectFiles(cds.root, ['.properties'])
+  if (req._.res) req._.res.set('content-type', 'application/octet-stream; charset=binary')
+
+  return packTarArchive([...cdsFiles, ...csvFiles, ...i18nFiles], cds.root)
+}
+
+const push = async function (req) {
+  let { extension } = req.data
+  if (!extension || !extension.data) req.reject(400, 'Missing extension')
+  const csn = await _compileProject(extension.data, req)
+  if (!csn) req.reject(400, 'Missing or bad extension')
+  const tenant = req.tenant
+  await validateExtension(csn, tenant, req)
+
+  const ID = cds.utils.uuid()
+  await cds.tx({ tenant }, async tx => {
+    await tx.run(
+      INSERT.into('cds.xt.Extensions').entries([
+        { ID, csn: JSON.stringify(csn), sources: extension.data, activated: 'database' }
+      ])
+    )
+  })
+
+  await activate(ID, null, tenant)
+}
+
+module.exports = { base, push }

package/libx/_runtime/extensibility/service.js

@@ -0,0 +1,21 @@
+const cds = require('../cds')
+
+const addExtension = require('./addExtension')
+const { add, promote } = require('./add')
+const { base, push } = require('./push')
+const { transformExtendedFieldsCREATE, transformExtendedFieldsUPDATE } = require('./handler/transformWRITE')
+const { transformExtendedFieldsREAD } = require('./handler/transformREAD')
+const { transformExtendedFieldsRESULT } = require('./handler/transformRESULT')
+
+module.exports = async function () {
+  this.on('addExtension', addExtension)
+  this.on('add', add)
+  this.on('promote', promote)
+  this.on('base', base)
+  this.on('push', push)
+  cds.db
+    .before('CREATE', transformExtendedFieldsCREATE)
+    .before('UPDATE', transformExtendedFieldsUPDATE)
+    .before('READ', transformExtendedFieldsREAD)
+    .after('READ', transformExtendedFieldsRESULT)
+}

package/libx/_runtime/extensibility/{uiflex/utils.js → utils.js}

@@ -1,5 +1,8 @@
-const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
-const { ensureUnlocalized } = require('../../fiori/utils/handler')
+const fs = require('fs')
+const path = require('path')
+
+const { ensureNoDraftsSuffix } = require('../common/utils/draft')
+const { ensureUnlocalized } = require('../fiori/utils/handler')
 
 const EXT_BACK_PACK = 'extensions__'
 
@@ -83,11 +86,44 @@ const getExtendedFields = (entityName, model) => {
     })
 }
 
+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 collectFiles = (dir, extensions) => {
+  const files = []
+  fs.readdirSync(dir).forEach(file => {
+    const abs = path.join(dir, file)
+    if (fs.statSync(abs).isDirectory() && !abs.includes('node_modules')) files.push(...collectFiles(abs, extensions))
+    else if (!extensions || extensions.includes(path.extname(abs))) files.push(abs)
+  })
+
+  return files
+}
+
+const exists = async fileOrDir => {
+  try {
+    return await fs.promises.stat(fileOrDir)
+  } catch (_) {
+    return false
+  }
+}
+
 module.exports = {
   EXT_BACK_PACK,
   getTargetRead,
   getTargetWrite,
   isExtendedEntity,
   hasExtendedEntity,
-  getExtendedFields
+  getExtendedFields,
+  getCompilerError,
+  collectFiles,
+  exists
 }

package/libx/_runtime/extensibility/validation.js

@@ -0,0 +1,53 @@
+const cds = require('../cds')
+
+const { getCompilerError } = require('./utils')
+
+const validateCsn = (csn, req) => {
+  if (!csn) req.reject(400, 'Missing extension')
+  if (!csn.extensions) return
+
+  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 = (csn, req) => {
+  if (!csn.extensions) return
+
+  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 validateExtension = async (ext, tenant, req) => {
+  try {
+    const { 'cds.xt.ModelProviderService': mps } = cds.services
+    const csn = await mps.getCsn(tenant, ['*'])
+    const extCsn = cds.compile.to.json(ext)
+    await cds.compile.to.csn({ 'base.csn': JSON.stringify(csn), 'ext.csn': extCsn })
+  } catch (err) {
+    req.reject(400, getCompilerError(err.messages))
+  }
+}
+
+module.exports = {
+  validateCsn,
+  validateExtensionFields,
+  validateExtension
+}

package/libx/_runtime/extensibility/views.js

@@ -0,0 +1,12 @@
+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
+}
+
+module.exports = resolveViews

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

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