@sap/cds 6.0.2 → 6.1.0

package/srv/model-provider.js

@@ -1,19 +1,40 @@
-/* eslint-disable no-console */
-const fs = require('fs')
+const { packTarArchive, unpackTarArchive } = require('../lib/utils/resources')
+const { collectFiles } = require('../libx/_runtime/extensibility/utils')
+const fs = require('fs').promises
+const os = require('os')
 const path = require('path')
 
-const cds = require('../libx/_runtime/cds')
+const cds = require('../lib')
+const conf = cds.requires['cds.xt.ModelProviderService'] || cds.requires.kinds['cds.xt.ModelProviderService']
+const main = conf.root ? new class { //> we're running in sidecar -> use env of main app
+  get env() { return super.env = cds.env.for ('cds', this.root) }
+  get root() { return super.root = path.resolve (cds.root, conf.root) }
+  get requires() { return super.requires = this.env.requires }
+  cache = {} //> for cds.resolve()
+} : { //> not in sidecar
+  requires: cds.requires,
+  root: cds.root,
+  env: cds.env,
+}
+const fts = main.env.features.folders
 const DEBUG = cds.debug('mtx')
-
-const { packTarArchive, unpackTarArchive } = require('../lib/utils/resources')
-const { collectFiles } = require('../libx/_runtime/extensibility/utils')
+if (DEBUG) cds.once('served', ()=> DEBUG ('model provider options:', conf))
 
 
-const TEMP_DIR = fs.realpathSync(require('os').tmpdir())
+module.exports = class ModelProviderService extends cds.ApplicationService {
 
-module.exports = class ModelProviderService extends cds.Service {
+  /**
+   * Overload `.on` to decorate handlers to set `cds.context.tenant` based on incoming arg `tenant`.
+   */
+  on (event, handler) {
+    return super.on(event, (req) => {
+      if (req.data.tenant) cds.context = { tenant: req.data.tenant }
+      // REVISIT: might not be correct when called via ExtensibilityService.add(...)
+      //> const tenant = req.tenant || (req.user.is('internal-user') && req.data.tenant)
+      return handler(req)
+    })
+  }
 
-  get _add_stub_methods(){ return true }
   init() {
 
     // REVISIT: We should do the enforcement only in production
@@ -24,13 +45,20 @@ module.exports = class ModelProviderService extends cds.Service {
     //   if (!requires.some(r => req.user.is(r))) return req.reject({ code:403 })
     // })
 
-    this.on('getCsn', req => _getCsn(req, false, this._nodejs_models))
-    this.on('getExtCsn', req => _getExtCsn(req, this._nodejs_models))
+    this._in_sidecar = (conf.kind === 'in-sidecar') // REVISIT: eliminate this 'private API' if possible
+
+    this.on('getCsn', req => _getCsn(req))
+    this.on('getExtCsn', req => {
+      if (!main.requires.extensibility) return req.reject(400, 'Missing extensibility parameter')
+      return _getCsn (req, true)
+    })
+
     this.on('getEdmx', async req => {
+      const { res } = req._; if (res) res.set('Content-Type', 'application/xml')
       const { service, locale, flavor } = req.data
-      const csn = await _getCsn(req, false, this._nodejs_models)
+      delete req.data.flavor // we need to delete the OData 'flavor' argument, as getCsn has a different CSN `flavor` argument
+      const csn = await _getCsn(req)
       const edmx = cds.compile.to.edmx(csn, { service, flavor })
-      const {res} = req._; if (res) res.set('Content-Type', 'application/xml')
       return cds.localize(csn, locale, edmx)
     })
 
@@ -39,125 +67,77 @@ module.exports = class ModelProviderService extends cds.Service {
       // REVISIT: Works only w/o encoding parameter. Default encoding is 'utf8'.
       // try { return await cds.utils.read('resources.tgz') }
       // root is defined in cds.requires, in case of the sidecar scenario it is set to "_main"
-      try { return await require('fs').promises.readFile(require('path').resolve(cds.root, conf?.root || '', 'resources.tgz')) }
+      try { return await fs.readFile (path.resolve (main.root, 'resources.tgz')) }
       catch(e) { if (e.code !== 'ENOENT') throw e }
       const files = Object.keys(await cds.deploy.resources(['*', cds.env.features.folders]))
       if (!files.length) return req.reject(404)
       if (req._.res) req._.res.set('content-type', 'application/octet-stream; charset=binary')
-      return packTarArchive(files, cds.root)
+      return packTarArchive (files, cds.root)
     })
 
     this.on('getExtResources', async req => {
-      if (!cds.requires.extensibility) return req.reject(400, 'Missing extensibility parameter')
-      const rs = await run4 (req.data.tenant, SELECT('sources').from('cds.xt.Extensions'))
+      if (!main.requires.extensibility) return req.reject(400, 'Missing extensibility parameter')
+      const rs = await SELECT('sources').from('cds.xt.Extensions')
       if (!rs.length) return req.reject(404, 'Missing extensions')
       if (rs.every(row => row.sources === null)) return req.reject(404, 'Extension resources not found')
       if (req._.res) req._.res.set('content-type', 'application/octet-stream; charset=binary')
-      const temp = await fs.promises.mkdtemp(`${TEMP_DIR}${path.sep}tar-`)
+      const tmp = await fs.realpath(os.tmpdir())
+      const dir = await fs.mkdtemp(tmp + path.sep + 'tar-') // REVISIT: hase to be exactly this folder -> weird
       try {
-        await Promise.all (rs.map (row => unpackTarArchive(Buffer.from(JSON.parse(row.sources)), temp, false)))
-        return await packTarArchive(collectFiles(temp, ['.csv', '.properties']), temp)
+        await Promise.all (rs.map (row => unpackTarArchive (Buffer.from(row.sources), dir, false))) // REVISIT: use pipe instead
+        return await packTarArchive (collectFiles (dir, ['.csv', '.properties']), dir) // REVISIT: better tar APIs -> collectFiles should not be required
       } finally {
-        await (fs.promises.rm || fs.promises.rmdir)(temp, { recursive: true, force: true }).catch(()=>{})
+        await fs.rm (dir, { recursive: true, force: true }).catch(()=>{})
       }
     })
 
-    this.on('isExtended', async req => _isExtended(req.data.tenant))
+    this.on('isExtended', async req => {
+      if (!main.requires.extensibility) return false
+      if (!req.data.tenant && main.requires.multitenancy) return false
+      const one = await SELECT.one(1).from('cds.xt.Extensions')
+      return !!one
+    })
 
     this.on('getExtensions', async req => {
-      if (!cds.requires.extensibility) return req.reject(400, 'Missing extensibility parameter')
-      const exts = await run4 (req.data.tenant, SELECT('csn').from('cds.xt.Extensions'))
-      if (!exts.length) return req.reject(404, 'Missing extensions')
-
-      const csn = { extensions: [], definitions: {} }
-      exts.forEach(ext => {
-        const extCsn = JSON.parse(ext.csn)
-        csn.extensions.push(...extCsn.extensions)
-        if (extCsn.definitions) csn.definitions = Object.assign(extCsn.definitions, csn.definitions)
-      })
-
-      return csn
+      if (!main.requires.extensibility) return req.reject(400, 'Missing extensibility parameter')
+      return await _getExtensions4(req.data.tenant) || req.reject(404, 'Missing extensions')
     })
 
-    this.invalidateCache = tenant => {
-      for (const key in this._nodejs_models) {
-        if (key.startsWith( `${tenant}:`)) {
-          delete this._nodejs_models[key]
-        }
-      }
-    }
-
-    // Conf vars required by getCsn ------------------------------------------
-    // eslint-disable-next-line one-var
-    const conf = cds.env.requires['cds.xt.ModelProviderService'] || cds.env.requires.kinds['cds.xt.ModelProviderService']
-    DEBUG && DEBUG ('ModelProviderService options:', conf)
-    const options = {}
-    if (conf.root) {
-      options.root = path.resolve (cds.root, conf.root)
-      options.env = cds.env.for('cds', options.root)
-      options.cache = {}
-    }
-    const fts = cds.env.features.folders
-    if (conf.kind !== 'in-sidecar') this._nodejs_models = {}
+    /** Implementation for getCsn */
+    async function _getCsn (req, checkExt) {
+      const { tenant, toggles, base, flavor, for:javaornode } = req.data
+      const extensions = !base && await _getExtensions4 (req.data.tenant)
+      if (!extensions && checkExt) req.reject(404, 'Missing extensions')
 
-    /** The implementation for getCsn */
-    async function _getCsn (req, checkExt, cache) {
-      const { toggles, for:javaornode } = req.data
       const features = !toggles ? [] : toggles === '*' || toggles.includes('*') ? [fts] : toggles.map (f => fts.replace('*',f))
-      const isExtended = await _isExtended(req.data.tenant)
-      if (checkExt && !isExtended) req.reject(404, 'Missing extensions')
-      const hash = `${isExtended ? req.data.tenant : undefined}:${features.join(',')}`
-      if (javaornode && cache && cache[hash]) return cache[hash]
-
-      const models = cds.resolve(['*',...features], options)
-      if (!models) return
+      const models = cds.resolve (['*',...features], main); if (!models) return
 
-      DEBUG && DEBUG ('loading models from', models)
-      let csn = await cds.load(models).then(cds.minify)
-      if (isExtended) csn = await _addExtensions(csn, req.data.tenant)
-      if (javaornode) csn = cds.compile.for[javaornode](csn)
+      DEBUG && DEBUG ('loading models for', { tenant, toggles } ,'from', models.map (cds.utils.local))
+      let csn = await cds.load (models, { flavor, silent:true })
+      if (csn.meta?.flavor === 'inferred') csn = cds.minify (csn)
+      if (extensions) csn = cds.extend (csn) .with (extensions)
+      if (javaornode) csn = cds.compile.for[javaornode] (csn)
 
       // Dirty hack for cds.localize in Node sidecar setup
-      Object.defineProperty(csn,'$sources',{ value:csn.$sources, enumerable:true })
-
-      if (javaornode && cache) cache[hash] = csn
-
+      Object.defineProperty (csn,'$sources',{ value:csn.$sources, enumerable:true })
       return csn
     }
 
-    async function _getExtCsn (req, cache) {
-      if (!cds.requires.extensibility) return req.reject(400, 'Missing extensibility parameter')
-      return _getCsn (req, true, cache)
-    }   
-  }
-}
-
-
-const run4 = (t,q) => t ? cds.tx({tenant:t}, tx => tx.run(q)) : q
-
-/** Add extensions if applicable and exist */
-const _addExtensions = async (csn, tenant) => {  
-  const exts = await run4 (tenant, SELECT('csn').from('cds.xt.Extensions'))
-  if (!exts.length) return csn
+    /** Implementation for getExtensions */
+    async function _getExtensions4 (tenant) {
+      if (!main.requires.extensibility || !tenant && main.requires.multitenancy) return
+      const exts = await SELECT('csn').from('cds.xt.Extensions'); if (!exts.length) return
+      const merged = { extensions: [], definitions: {} }
+      for (let each of exts) {
+        let {definitions,extensions} = JSON.parse(each.csn)
+        if (definitions) Object.assign (merged.definitions, definitions)
+        if (extensions) merged.extensions.push (...extensions)
+      }
+      return merged
+    }
 
-  const all = { definitions: {}, extensions: [] }
-  for (const each of exts) {
-    const ext = JSON.parse(each.csn)
-    if (ext.definitions) Object.assign(all.definitions, ext.definitions)
-    if (ext.extensions) all.extensions.push(...ext.extensions)
   }
-  const extended = cds.compile({
-    'base.csn': cds.compile.to.json(csn),
-    'ext.csn': cds.compile.to.json(all)
-  })
-  extended.$sources = csn.$sources // required to load resources like i18n later on
-
-  return extended
-}
 
-async function _isExtended (tenant) {
-  if (!cds.requires.extensibility) return false
-  if (!tenant && cds.requires.multitenancy) return false
-  const one = await run4 (tenant, SELECT.one(1).from('cds.xt.Extensions'))
-  return !!one
+  get isExtensible () { return false } // REVISIT: Do we want to keep this?
 }
+module.exports.prototype._add_stub_methods = true

package/srv/mtx.js

@@ -1,7 +1,13 @@
 const cds = require ('../lib')
+const DEBUG = cds.debug('mtx')
+
 class MTXServices extends cds.Service { async init(){
-  if (cds.mtx) return cds.mtx?.in (cds.app) // old mtx
+  if (cds.mtx) {
+    DEBUG && DEBUG ('bootstrapping old MTX...')
+    return cds.mtx.in (cds.app) // old mtx
+  }
   // else...
+  DEBUG && DEBUG ('bootstrapping MTX services...')
   let sources = []
   if (cds.requires.multitenancy) {
     if (!('cds.xt.DeploymentService' in cds.requires)) {

package/libx/_runtime/cds-services/adapter/odata-v4/Dispatcher.js

@@ -1,240 +0,0 @@
-const cds = require('../../../cds')
-const LOG = cds.log('odata')
-
-const { normalizeError } = require('../../../common/error/frontend')
-
-const _run4 = (tenant, query) => (tenant ? cds.tx({ tenant }, tx => tx.run(query)) : query)
-const getError = require('../../../common/error')
-
-// REVISIT: this is always active, even without mtx -> do that better
-module.exports = class Dispatcher {
-  /**
-   * Constructs an Dispatcher for cds service.
-   * New OData services will be created.
-   *
-   * @param service
-   */
-  constructor(service) {
-    this._serviceName = service.definition.name
-    this._options = service.options
-
-    this._extMap = new Map()
-    this._extMap.set(getModelHash(), createOdataService(service))
-    this._intervalMap = new Map()
-    this._intervalMap.set(undefined, Date.now())
-
-    if (cds.mtx) {
-      cds.mtx._nodejs_models = {}
-      cds.mtx.eventEmitter.on(cds.mtx.events.TENANT_UPDATED, async tenant => {
-        this._extMap.delete(getModelHash(tenant))
-        delete cds.mtx._nodejs_models[tenant]
-      })
-    }
-
-    this._tenantCheckInterval = cds.requires.extensibility && cds.requires.extensibility.tenantCheckInterval
-  }
-
-  _deleteService(tenant) {
-    const hash = getModelHash(tenant)
-    for (const entry of this._extMap.entries()) {
-      if (entry[0].startsWith(hash)) {
-        this._extMap.delete(entry[0])
-      }
-    }
-    this._intervalMap.delete(tenant)
-  }
-
-  async _checkTenantExt(tenant, last) {
-    try {
-      const rs = await _run4(tenant, SELECT(1).from('cds.xt.Extensions').where('timestamp >=', last))
-      if (!this._mps) this._mps = await cds.connect.to('cds.xt.ModelProviderService')
-      if (rs.length) {
-        this._deleteService(tenant)
-        this._mps.invalidateCache(tenant)
-      } else {
-        this._intervalMap.set(tenant, Date.now())
-      }
-    } catch (_) {
-      this._deleteService(tenant)
-    }
-  }
-
-  async _getService4Tenant(req) {
-    // here, req is express' req -> req.tenant not available
-    const tenant = req.user && req.user.tenant
-    const isExtended = await cds.mtx.isExtended(tenant) // REVISIT: avoid await
-    if (!isExtended) return false
-
-    let model = cds.mtx._nodejs_models[tenant]
-    if (!model) {
-      const raw = await cds.mtx.getCsn(tenant)
-      model = cds.mtx._nodejs_models[tenant] = cds.compile.for.nodejs(raw)
-    }
-
-    const service = await createNewService(this._serviceName, model, this._options)
-    service._cdsService._isExtended = true
-    return service
-  }
-
-  async _getService4(tenant, features) {
-    const model = await this._mps.getCsn(tenant, features || [], 'nodejs')
-    return createNewService(this._serviceName, model, this._options)
-  }
-
-  async _getService(tenant, features, hash, req) {
-    if (cds.mtx) {
-      const service = await this._getService4Tenant(req)
-
-      if (service) return service
-
-      return this._extMap.get(getModelHash())
-    }
-
-    if (!this._mps) this._mps = await cds.connect.to('cds.xt.ModelProviderService')
-    const hashBase = getModelHash(undefined, features)
-    if (tenant && tenant !== undefined && hash !== hashBase) {
-      const isExtended = cds.requires.extensibility && (await this._mps.isExtended(tenant))
-      if (isExtended) {
-        return this._getService4(tenant, features)
-      } else {
-        if (!this._extMap.has(hashBase)) {
-          this._extMap.set(hashBase, this._getService4(undefined, features))
-          this._intervalMap.set(tenant, Date.now())
-        }
-        return this._extMap.get(hashBase)
-      }
-    } else {
-      return this._getService4(undefined, features)
-    }
-  }
-
-  async _handleError(err, hash, req, res) {
-    if (LOG._error) {
-      err.message = 'Unable to get service from service map due to error: ' + err.message
-      LOG.error(err)
-    }
-    // clear map entry
-    this._extMap.delete(hash)
-    // return 503 to client
-    err = getError(Object.assign(err, { statusCode: 503 }))
-    const { error } = normalizeError(err, req)
-
-    return res.status(503).send({ error })
-  }
-
-  _hasModelProvider() {
-    return 'cds.xt.ModelProviderService' in cds.services || 'cds.xt.ModelProviderService' in cds.requires
-  }
-
-  /**
-   * Dispatch request in case of extensibility to other odata adapters.
-   *
-   * @param req
-   * @param res
-   * @private
-   * @returns {Promise}
-   */
-  async dispatch(req, res) {
-    // here, req is express' req -> req.tenant not available
-    // REVISIT: rethink authentication
-    const tenant = req.user && req.user.tenant
-
-    // single tenant w/o features
-    if (!cds.mtx && !this._hasModelProvider()) {
-      const service = this._extMap.get(getModelHash())
-      return service.process(req, res)
-    }
-
-    // old mtx does not support feature toggles
-    const features = cds.mtx ? [] : _features4(req.features || req.user.features)
-    const hash = getModelHash(tenant, features)
-
-    // check for extensions
-    if (cds.requires.extensibility && !this._inCheckTenant) {
-      this._inCheckTenant = true
-      if (this._intervalMap.has(tenant)) {
-        const last = this._intervalMap.get(tenant)
-        if (Date.now() - last > this._tenantCheckInterval)
-          await this._checkTenantExt(tenant, new Date(last).toISOString())
-      }
-      this._inCheckTenant = false
-    }
-
-    // set promise into the map to avoid conflicts
-    if (!this._extMap.has(hash)) {
-      this._extMap.set(hash, this._getService(tenant, features, hash, req))
-      this._intervalMap.set(tenant, Date.now())
-    }
-
-    let service
-    try {
-      service = await this._extMap.get(hash)
-    } catch (err) {
-      return this._handleError(err, hash, req, res)
-    }
-
-    service.process(req, res)
-  }
-
-  /**
-   * Return service middleware, which can be used by node server, express, connect, ...
-   *
-   * @returns {Function}
-   */
-  getService() {
-    return (req, res) => {
-      this.dispatch(req, res)
-    }
-  }
-}
-
-// -----------------------------------------------------
-// Private utils...
-
-const OData = require('./OData')
-const DEBUG = cds.debug('extensibility')
-
-const { alias2ref } = require('../../../common/utils/csn')
-
-function createOdataService(service) {
-  const name = (service.definition && service.definition.name) || service.name
-  const edm = cds.compile.to.edm(service.model, { service: name })
-  alias2ref(service, edm)
-
-  const odataService = new OData(edm, service.model, service.options)
-  odataService.addCDSServiceToChannel(service)
-
-  return odataService
-}
-
-async function createNewService(name, model, options) {
-  const { constructor: Service, path } = cds.services[name]
-  const service = new Service(name, model, { ...options }) // cloning options to be safe
-  if (service.init) await service.prepend(service.init)
-  if (options.impl) await service.prepend(options.impl)
-  if (path) service.path = path
-  DEBUG &&
-    DEBUG('Created tenant-specific service:', service.name, '= new', Service.name, {
-      _handlers: {
-        on: service._handlers.on.map(h => ({ on: h.on, handler: () => {} }))
-      }
-    })
-  return createOdataService(service)
-}
-
-const getModelHash = (tenant, features) => {
-  // ignore tenant in single tenant mode - use default (undefined) hash
-  const hash = cds.requires.multitenancy ? `${tenant}:` : 'undefined:'
-  return !features ? hash : hash + features.join(';')
-}
-
-const _features4 = features => {
-  // ensure features is an array
-  if (!features) return []
-  if (Array.isArray(features)) return features
-  if (typeof features === 'string') return features.split(',')
-  if (typeof features === 'object')
-    return Object.keys(features)
-      .filter(k => features[k])
-      .sort()
-}