@sap/cds 5.5.5 → 5.6.0

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)
+  })
+}

package/libx/_runtime/fiori/uiflex/utils.js

@@ -0,0 +1,78 @@
+const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
+const { ensureUnlocalized } = require('../../fiori/utils/handler')
+
+const EXT_BACK_PACK = 'extensions__'
+
+const getTargetRead = req => {
+  let name = ''
+  if (req.query.SELECT.from.join) {
+    // join
+    name = req.query.SELECT.from.args.find(arg => arg.ref && arg.ref[0] !== 'DRAFT.DraftAdministativeData').ref[0]
+  } else if (req.target.name.SET) {
+    // union
+    name = req.target.name.SET.args[0]._target.name
+  } else {
+    // simple select
+    name = req.target.name
+  }
+
+  return { name: ensureUnlocalized(ensureNoDraftsSuffix(name)) }
+}
+
+const getTargetWrite = (target, model) => {
+  return model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(target.name))]
+}
+
+const isExtendedEntity = (entityName, model) => {
+  // REVISIT: Dass alle unsere und auch custom handlers immer die ensureUnlocalized + ensureNoDraftsSuffix schleife drehen müssen, kann nicht sein
+  const entity = model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(entityName))]
+  return entity.elements[EXT_BACK_PACK] || Object.values(entity.elements).some(el => el['@cds.extension'])
+}
+
+const _hasExtendedEntityArgs = (args, model) => {
+  return args.find(arg => {
+    if (arg.ref) {
+      return arg.ref[0] !== 'DRAFT.DraftAdministativeData' && isExtendedEntity(arg.ref[0], model)
+    }
+
+    if (arg.join) {
+      return _hasExtendedEntityArgs(arg.args, model)
+    }
+  })
+}
+
+const hasExtendedEntity = (req, model) => {
+  if (!req.query.SELECT) return false
+
+  if (req.query.SELECT.from.join) {
+    // join
+    return _hasExtendedEntityArgs(req.query.SELECT.from.args, model)
+  } else if (req.target.name.SET) {
+    // union
+    return isExtendedEntity(req.target.name.SET.args[0]._target.name, model)
+  } else {
+    // simple select
+    return isExtendedEntity(req.target.name, model)
+  }
+}
+
+const getExtendedFields = (entityName, model) => {
+  const elements = model.definitions[ensureUnlocalized(ensureNoDraftsSuffix(entityName))].elements
+
+  return Object.values(elements)
+    .filter(element => {
+      return element['@cds.extension']
+    })
+    .map(element => {
+      return element.name
+    })
+}
+
+module.exports = {
+  EXT_BACK_PACK,
+  getTargetRead,
+  getTargetWrite,
+  isExtendedEntity,
+  hasExtendedEntity,
+  getExtendedFields
+}

package/libx/_runtime/fiori/utils/handler.js

@@ -231,11 +231,12 @@ const addColumnAlias = (columns, alias) => {
 const getCompositionTargets = (entity, srv) => {
   if (!entity.own('_deepCompositionTargets')) {
     const _deepCompositionTargets = []
-    getTemplate('delete-drafts', srv, entity, {
+    getTemplate(undefined, srv, entity, {
       pick: element => {
         if (element.isAssociation && !element._isAssociationStrict && srv.model.definitions[element.target].drafts)
           _deepCompositionTargets.push(element.target)
-      }
+      },
+      ignore: element => !element.isAssociation || element._isAssociationStrict
     })
     entity.set('_deepCompositionTargets', new Set(_deepCompositionTargets))
   }
@@ -268,16 +269,6 @@ const getKeyProperty = keys => {
   })
 }
 
-const hasKeyInWhere = (where, target) => {
-  if (!where) {
-    return false
-  }
-
-  const key = getKeyProperty(target.keys)
-
-  return where.some(element => (element.ref ? key === element.ref[element.ref.length - 1] : false))
-}
-
 const filterKeys = keys => {
   return Object.keys(keys).filter(key => {
     return key !== 'IsActiveEntity' && !keys[key]._isAssociationStrict
@@ -301,7 +292,6 @@ module.exports = {
   adaptStreamCQN,
   replaceRefWithDraft,
   getKeyProperty,
-  hasKeyInWhere,
   filterKeys,
   getDeleteDraftAdminCqn,
   getCompositionTargets

package/libx/_runtime/fiori/utils/where.js

@@ -55,6 +55,9 @@ const _removeIsActiveEntityCondition = where => {
       i = i + 4
     } else if (where[i] === 'and' && where[i + 1] === '(' && _isActiveEntity(where[i + 2])) {
       i = i + 6
+    } else if (where[i].xpr) {
+      newWhere.push({ xpr: _removeIsActiveEntityCondition(where[i].xpr) })
+      i++
     } else {
       newWhere.push(where[i])
       i++
@@ -132,7 +135,7 @@ const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
 const removeIsActiveEntityRecursively = where => {
   for (const entry of where) {
     if (entry.SELECT && entry.SELECT.where && entry.SELECT.from.ref && !entry.SELECT.from.ref[0].endsWith('_drafts')) {
-      entry.SELECT.where = _removeIsActiveEntityCondition(entry.SELECT.where)
+      entry.SELECT.where = removeIsActiveEntityRecursively(entry.SELECT.where)
 
       if (entry.SELECT.where.length === 0) {
         delete entry.SELECT.where
@@ -144,6 +147,8 @@ const removeIsActiveEntityRecursively = where => {
 }
 
 const isActiveEntityRequested = where => {
+  if (!where) return true
+
   let i = 0
 
   while (where[i]) {

package/libx/_runtime/hana/pool.js

@@ -9,19 +9,20 @@ const _require = require('../common/utils/require')
 let im
 
 function multiTenantInstanceManager(db = cds.env.requires.db) {
-  let creds = db.credentials && (db.credentials.get_managed_instance_url || db.credentials.sm_url) && db.credentials
-  if (!creds) creds = _require('@sap/xsenv').serviceCredentials(db.vcap || { label: 'managed-hana' })
-  if (!creds) creds = _require('@sap/xsenv').serviceCredentials({ label: 'service-manager' })
-
-  if (!creds || typeof creds !== 'object' || !(creds.get_managed_instance_url || creds.sm_url)) {
-    throw Object.assign(new Error('No or malformed Managed HANA credentials'), { credentials: creds })
+  const credentials = db.credentials
+  if (
+    !credentials ||
+    typeof credentials !== 'object' ||
+    !(credentials.get_managed_instance_url || credentials.sm_url)
+  ) {
+    throw Object.assign(new Error('No or malformed db credentials'), { credentials: credentials })
   }
 
   // new instance manager
   return new Promise((resolve, reject) => {
     // REVISIT: better cache settings? current copied from old cds-hana...
     // note: may need to be low for mtx tests -> configurable?
-    const opts = Object.assign(creds, {
+    const opts = Object.assign(credentials, {
       cache_max_items: 1,
       cache_item_expire_seconds: 1
     })
@@ -37,16 +38,16 @@ function multiTenantInstanceManager(db = cds.env.requires.db) {
 }
 
 function singleTenantInstanceManager(db = cds.env.requires.db) {
-  const creds = db.credentials || _require('@sap/xsenv').serviceCredentials(db.vcap || { label: 'hana' })
+  const credentials = db.credentials
 
-  if (!creds || typeof creds !== 'object' || !creds.host) {
-    throw Object.assign(new Error('No or malformed HANA credentials'), { credentials: creds })
+  if (!credentials || typeof credentials !== 'object' || !credentials.host) {
+    throw Object.assign(new Error('No or malformed db credentials'), { credentials: credentials })
   }
 
   // mock instance manager
   return {
     get: (_, cb) => {
-      cb(null, { credentials: creds })
+      cb(null, { credentials: credentials })
     }
   }
 }