@sap/cds 5.8.4 → 5.9.2

package/libx/_runtime/common/toggles/alpha.js

@@ -1,43 +0,0 @@
-/*
- * additions for feature toggles
- */
-module.exports = cds => {
-  if (!cds.env.features.alpha_toggles) return (req, res, next) => next()
-
-  return (req, res, next) => {
-    // attach _getHash helper to mtx
-    if (!cds.mtx._getHash) {
-      cds.mtx._getHash = req => {
-        let hash = req.tenant
-        if (req.features) hash += ':' + Object.keys(req.features).join(';')
-        return hash
-      }
-    }
-
-    // inject features from dwc header
-    const fth = req.headers['dwc-product-configuration']
-    if (fth) {
-      const { features } = JSON.parse(Buffer.from(fth, 'base64').toString('utf-8'))
-      req.features = features
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .reduce((acc, cur) => {
-          if (cur.enabled) acc[cur.name] = 1
-          return acc
-        }, {})
-    }
-
-    // extend @sap/cds's dispatch listener
-    const {
-      eventEmitter: mtx,
-      events: { TENANT_UPDATED }
-    } = cds.mtx
-    req.on('dispatch', req => {
-      // clear ext map for next request as soon as it was dispatched
-      mtx.emit(TENANT_UPDATED, cds.mtx._getHash(req._.req))
-      // set cds.context.features here so we don't need to touch @sap/cds
-      cds.context.features = req._.req.features
-    })
-
-    next()
-  }
-}

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

@@ -1,33 +0,0 @@
-const { getEntityFromCQN } = require('../../common/utils/entityFromCqn')
-const getTemplate = require('../../common/utils/template')
-const templateProcessor = require('../../common/utils/templateProcessor')
-
-const _pick = element => {
-  if (element.kind === 'element' && element.items) return 'arrayed'
-}
-
-const _processFn = ({ row, key, plain }) => {
-  if (plain === 'arrayed' && row && row[key] && (typeof row[key] === 'string' || Buffer.isBuffer(row[key]))) {
-    row[key] = JSON.parse(row[key])
-  }
-}
-
-/**
- * Formats JSON Strings to arrayed data
- *
- * @param result - the result of the DB query
- * @param req - the context object
- * @returns {Promise}
- */
-module.exports = function (result, req) {
-  if (!this.model) return
-
-  const entity = getEntityFromCQN(req, this)
-  if (!entity) return
-
-  const template = getTemplate('db-arrayed', this, entity, { pick: _pick })
-  if (template.elements.size === 0) return
-
-  for (const row of Array.isArray(result) ? result : [result])
-    templateProcessor({ processFn: _processFn, row, template })
-}

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

@@ -1,35 +0,0 @@
-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, '../../../..', 'srv/flex.cds')
-    return cds.serve(model, { silent: true }).to('odata').in(cds.app)
-  })
-}

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

@@ -1,150 +0,0 @@
-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 _needsQuotations = t => t instanceof cds.builtin.classes.string || t instanceof cds.builtin.classes.date
-
-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 && _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 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/rest/utils/data.js

@@ -1,60 +0,0 @@
-const { deepCopyObject } = require('../../_runtime/common/utils/copy')
-const { checkKeys, checkStatic } = require('../../_runtime/cds-services/util/assert')
-const { MULTIPLE_ERRORS } = require('../../_runtime/common/error/constants')
-
-// this can be reused for flattening data on db layer, if necessary
-// const _getFlattenedCopy = (data, key, entity) => {
-//   const d = {}
-//   const prefix = key + '_'
-//   // TODO: ignore or preserve unknown?
-//   const matches = Object.keys(entity.elements)
-//     .filter(ele => ele.startsWith(prefix))
-//     .map(ele => ele.replace(prefix, ''))
-//   if (matches.length) {
-//     const current = data[key]
-//     for (const k of matches) if (current[k] !== undefined) d[prefix + k] = current[k]
-//     const nested = Object.keys(current).filter(k => current[k] && typeof current[k] === 'object')
-//     for (const k of nested) Object.assign(d, _getFlattenedCopy({ [prefix + k]: current[k] }, prefix + k, entity))
-//   }
-//   return d
-// }
-
-const _getDeepCopy = (data, definition, model, validations, skipKeys) => {
-  skipKeys || (definition.keys && validations.push(...checkKeys(definition, data)))
-  validations.push(...checkStatic(definition, data, true))
-
-  const d = {}
-  for (const k in data) {
-    const element = (definition.elements && definition.elements[k]) || (definition.params && definition.params[k])
-    if (!element) {
-      if (!definition['@open']) {
-        // ignore input (the default)
-      } else {
-        d[k] = data[k] && typeof data[k] === 'object' ? deepCopyObject(data[k]) : data[k]
-      }
-    } else if (element.isAssociation) {
-      d[k] = Array.isArray(data[k])
-        ? data[k].map(d => _getDeepCopy(d, model.definitions[element.target], model, validations))
-        : _getDeepCopy(data[k], model.definitions[element.target], model, validations)
-    } else if (element._isStructured) {
-      d[k] = _getDeepCopy(data[k], element, model, validations)
-    } else {
-      d[k] = data[k]
-    }
-  }
-  return d
-}
-
-const getDeepCopy = (data, definition, model, skipKeys) => {
-  const validations = []
-  const copy = Array.isArray(data)
-    ? data.map(d => _getDeepCopy(d, definition, model, validations, skipKeys))
-    : _getDeepCopy(data, definition, model, validations, skipKeys)
-  if (!validations.length) return [undefined, copy]
-  if (validations.length === 1) return [validations[0]]
-  return [Object.assign(new Error(MULTIPLE_ERRORS), { details: validations })]
-}
-
-module.exports = {
-  getDeepCopy
-}