@sap/cds 6.1.3 → 6.2.1

package/srv/mtx.js

@@ -1,37 +1,8 @@
-const cds = require ('../lib')
-const DEBUG = cds.debug('mtx')
-
-class MTXServices extends cds.Service { async init(){
+module.exports = ()=> {
+  const cds = require ('../lib')
   if (cds.mtx) {
+    const DEBUG = cds.debug('mtx')
     DEBUG && DEBUG ('bootstrapping old MTX...')
     return cds.mtx.in (cds.app) // old mtx
   }
-  // else...
-  DEBUG && DEBUG ('bootstrapping MTX services...')
-  let defs = cds.model.definitions
-  let sources = []
-
-  if (cds.requires.multitenancy && !('cds.xt.SaasProvisioningService' in defs)) {
-    sources.push('@sap/cds-mtxs/srv/cf/saas-provisioning-service')
-    sources.push('@sap/cds/srv/model-provider')
-  }
-
-  if (cds.requires.multitenancy && !('cds.xt.DeploymentService' in defs)) {
-    sources.push('@sap/cds-mtxs/srv/deployment-service')
-    sources.push('@sap/cds/srv/model-provider')
-  }
-
-  if (cds.requires.extensibility && !('cds.xt.ExtensibilityService' in defs)) {
-    sources.push('@sap/cds/srv/extensibility-service')
-    sources.push('@sap/cds/srv/model-provider')
-  }
-
-  if (cds.requires.toggles && !('cds.xt.ModelProviderService' in defs)) {
-    sources.push('@sap/cds/srv/model-provider')
-  }
-
-  let models = cds.resolve(sources); if (!models) return
-  let base = cds.model.$sources; models = models.filter(m => !base.includes(m))
-  if (models.length) return cds.serve(models).in(cds.app)
-}}
-module.exports = MTXServices
+}

package/lib/srv/adapters.js

@@ -1,85 +0,0 @@
-const lib = require('../../libx/_runtime')
-const cds = require('../index')
-const registry = {
-  get rest() { return lib.to.rest },
-  get odata() { return lib.to.odata_v4 },
-  get odata_v2() { return lib.to.odata_v4 },
-  get odata_v4() { return lib.to.odata_v4 },
-  get fiori() { return lib.to.odata_v4 },
-  none: ()=>{}
-}
-
-
-class ProtocolAdapter {
-
-  static at (protocol) {
-    const factory = registry[protocol]; if (factory) return factory
-    else throw new Error (`Service protocol ${protocol} is not supported`)
-  }
-
-  /**
-  * Constructs / returns a ProtocolAdapter for the given service and protocol.
-  * The constructed adapters are cached per service, so subsequent calls
-  * for same service and protocol returns the formerly constructed one.
-  * @returns {ProtocolAdapter}
-  */
-  static serve (srv, protocol = _protocol4(srv)) {
-    const cached = (srv._adapters || (srv._adapters={})) [protocol]; if (cached) return cached
-    const adapter = Object.defineProperties (this.at (protocol) (srv), _prototype)
-    return (adapter.service = srv)._adapters[protocol] = adapter
-  }
-
-  /**
-  * Mounts the adapter to an express app.
-  */
-  in (app) {
-    const srv = this.service
-    app.use (srv.path+'/webapp/', (_,res)=> res.sendStatus(404))
-    const cds_context_model = require('./srv-models')
-    app.use (srv.path, logger, lib.perf, lib.auth(srv), cds_context_model.middleware4(srv), this)
-    return srv
-  }
-
-  /**
-  * Returns a proxy handler function with the specified service
-  * as its prototype to allow usages like this:
-  *
-  *    const { CatalogService } = cds.serve(...)
-  *    app.use ('/cats', CatalogService)
-  */
-  asRouter() {
-    let router = this._router
-    if (!router) {
-      router = this._router = (...args) => this (...args)
-      Object.defineProperty (router, 'name', {value: this.service.name})
-      Object.setPrototypeOf (router, this.service)
-    }
-    return router
-  }
-
-}
-
-const _protocol4 = (srv) => {
-  const {to} = srv.options; if (to) return to
-  return _protocol4Service(srv.definition)
-}
-
-const _protocol4Service = (service) => {
-  return !service ? default_protocol : service['@protocol'] || service['@rest'] && 'rest' || service['@odata'] && 'odata_v4' || default_protocol
-}
-
-
-const LOG = cds.log(), DEBUG = cds.debug('server')
-const logger = function cap_req_logger (req,_,next) {
-  LOG && LOG (req.method, decodeURI(req.originalUrl), req.body||'')
-  if (/\$batch/.test(req.url))  req.on ('dispatch', (req) => {
-    LOG && LOG ('>', req.event, decodeURI(req._path), req._query||'')
-    if (DEBUG && req.query) DEBUG (req.query)
-  })
-  next()
-}
-
-
-const default_protocol = 'odata_v4'
-const _prototype = Object.getOwnPropertyDescriptors (ProtocolAdapter.prototype)
-module.exports = { ProtocolAdapter, _protocol4Service }

package/lib/utils/resources/index.js

@@ -1,48 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-
-const { packArchiveCLI, unpackArchiveCLI } = require('./tar')
-const { exists } = require('./utils')
-
-const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
-
-const packTarArchive = async (files, root, flat = false) => {
-  if (typeof files === 'string') return await packArchiveCLI(files)
-
-  let tgzBuffer, temp
-  try {
-    temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
-    for (const file of files) {
-      const fname = flat ? path.basename(file) : path.relative(root, file)
-      const destination = path.join(temp, fname)
-      const dirname = path.dirname(destination)
-      if (!await exists(dirname)) await fs.promises.mkdir(dirname, { recursive: true })
-      await fs.promises.copyFile(file, destination)
-    }
-
-    tgzBuffer = await packArchiveCLI(temp)
-  } finally {
-    if (await exists(temp)) {
-      await fs.promises.rm(temp, { recursive: true, force: true })
-    }
-  }
-
-  return tgzBuffer
-}
-
-const unpackTarArchive = async (buffer, folder) => {
-  const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
-  const tgz = path.join(temp, 'resources.tgz')
-  await fs.promises.writeFile(tgz, Buffer.from(buffer), 'binary')
-
-  try {
-    await unpackArchiveCLI(tgz, folder)
-  } finally {
-    if (await exists(temp)) await fs.promises.rm(temp, { recursive: true, force: true })
-  }
-}
-
-module.exports = {
-  packTarArchive,
-  unpackTarArchive
-}

package/lib/utils/resources/tar.js

@@ -1,49 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const exec = require('child_process').exec
-const cds = require('../../../libx/_runtime/cds')
-const { exists } = require('./utils')
-
-const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
-
-const _createArchiveCLI = (root, output) => {
-  const cmd = 'tar -zcvf ' + output + ' -C ' + root + '  .'
-
-  return new Promise((resolve, reject) => {
-    exec(cmd, err => {
-      if (err) reject(err)
-      else resolve()
-    })
-  })
-}
-
-const packArchiveCLI = async (root) => {
-  const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
-  const output = path.join(temp, `${cds.utils.uuid()}.tgz`)
-  try {
-    await _createArchiveCLI(root, output)
-
-    return fs.promises.readFile(output)
-  }
-  finally {
-    if (await exists(temp)) {
-      await fs.promises.rm(temp, { recursive: true, force: true })
-    }
-  }
-}
-
-const unpackArchiveCLI = async (tgz, folder) => {
-  const cmd = 'tar -xzf ' + tgz + ' -C ' + folder
-
-  return new Promise((resolve, reject) => {
-    exec(cmd, err => {
-      if (err) reject(err)
-      else resolve()
-    })
-  })
-}
-
-module.exports = {
-  packArchiveCLI,
-  unpackArchiveCLI
-}

package/lib/utils/resources/utils.js

@@ -1,11 +0,0 @@
-const fs = require('fs')
-
-const exists = async fileOrDir => {
-  try {
-    return await fs.promises.stat(fileOrDir)
-  } catch (_) {
-    return false
-  }
-}
-
-module.exports = { exists }

package/libx/_runtime/extensibility/activate.js

@@ -1,69 +0,0 @@
-const cds = require('../cds')
-
-const handleDefaults = require('./defaults')
-const Extensions = 'cds.xt.Extensions'
-
-// REVISIT: Reuse ratio = 0
-const _calculateExtensions = async function (ID, tag) {
-  let active, inactive
-  if (tag || ID) {
-    const inactiveCqn = SELECT.from(Extensions).where({ activated: 'propertyBag' })
-    if (ID) {
-      inactiveCqn.where('ID !=', ID)
-    } else {
-      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 }
-}
-
-// 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 cds.db.run(INSERT.into(Extensions).entries(inactive))
-  }
-}
-
-// 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(active, inactive, appCsn)
-}
-
-module.exports = activate

package/libx/_runtime/extensibility/add.js

@@ -1,50 +0,0 @@
-const cds = require('../cds')
-const LOG = cds.log('mtx')
-
-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.user.is('internal-user') && req.data.tenant) || req.tenant
-
-  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.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) {
-  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')
-
-  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

@@ -1,72 +0,0 @@
-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, appCsn) => {
-  csn.extensions.forEach(extension => {
-    const target = appCsn.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, 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' }
-    ])
-  )
-
-  for (const ext of req.data.extensions) {
-    const extension = JSON.parse(ext)
-    await handleDefaults(extension, appCsn, false)
-  }
-}
-
-const addExtension = async function (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,34 +0,0 @@
-const cds = require('../cds')
-const resolveViews = require('./views')
-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 e = elements[key],
-        { val } = e.default
-      const t = definitions[e.type] || builtin[e.type]
-      return `"${key}":${t && t[needsQuotes] ? `"${val}"` : val}`
-    })
-
-  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
-  }
-}
-
-module.exports = handleDefaults

package/libx/_runtime/extensibility/handler/transformREAD.js

@@ -1,121 +0,0 @@
-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
-  if (req.target) {
-    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 && req.query.SELECT.from.args) return _transformJoin(req, this.model) // join
-}
-
-module.exports = {
-  transformExtendedFieldsREAD
-}

package/libx/_runtime/extensibility/handler/transformRESULT.js

@@ -1,51 +0,0 @@
-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']
-}
-
-// The problem here are the extended columss, which are in SELECT.column, but not in the backpack.
-// Otherwise all backpack values could be inserted for row at once.
-const _processorFn = ({ row, key }) => {
-  if (row[EXT_BACK_PACK]) {
-    const extensions = JSON.parse(row[EXT_BACK_PACK])
-    if (extensions[key]) {
-      row[key] = extensions[key]
-      delete extensions[key]
-      if (Object.keys(extensions).length === 0) {
-        delete row[EXT_BACK_PACK]
-      } else {
-        row[EXT_BACK_PACK] = JSON.stringify(extensions)
-      }
-
-      return
-    }
-  }
-
-  // Extended fields are not in SELECT.columns.
-  // Workaround for fields not from backpack: provide them all
-  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
-}