@sap/cds 6.1.2 → 6.2.1

package/lib/srv/cds-serve.js

@@ -1,5 +1,5 @@
 const cds = require ('..')
-const { ProtocolAdapter } = cds.service.adapters
+const { ProtocolAdapter } = cds.service.protocols
 const { Service } = cds.service.factory
 const _ready = Symbol(), _pending = cds.services._pending || {}
 
@@ -63,7 +63,7 @@ module.exports = function cds_serve (som, _options) { // NOSONAR
       // skip all services marked to be ignored
       d['@cds.ignore'] || d['@cds.serve.ignore'] ||
       // skip external services, unless asked to mock them and unbound
-      (d['@cds.external'] || required[d.name]?.external) && (!o.mocked || required[d.name].credentials)
+      (d['@cds.external'] || required[d.name]?.external) && (!o.mocked || required[d.name]?.credentials)
     ))
     if (services.length > 1 && o.at) {
       throw cds.error `You cannot specify 'path' for multiple services`
@@ -80,7 +80,7 @@ module.exports = function cds_serve (som, _options) { // NOSONAR
     if (o.service && o.service._is_service_instance) return srv
     srv.init && await srv.prepend (srv.init)
     srv.options.impl && await srv.prepend (srv.options.impl)
-    cds.services[srv.name] = cds.service.paths[srv.path] = srv
+    cds.services[srv.name] = srv
     cds.service.providers.push (srv)
     if (srv[_ready]) srv[_ready](srv)
     return srv
@@ -100,24 +100,30 @@ module.exports = function cds_serve (som, _options) { // NOSONAR
       ready = ready.then (()=> all.forEach (each => {
         const d = each.definition
         if (d['@protocol'] === 'none' || d['@cds.api.ignore']) return each._is_dark = true
-        ProtocolAdapter.serve(each,o.to).in(app)
+        ProtocolAdapter.serve (each, /*in:*/ app)
         if (!o.silent) cds.emit ('serving',each)
       }))
       return this
     },
 
     /** Finally resolve to a single picked provider or a map of all */
-    then: (resolve, failed) => ready.then (()=>{
-      if (all.length === 0) return resolve()
-      let response={}
-      for (let each of all) {
-        response[each.name] = each._is_dark || !each.definition ? each : ProtocolAdapter.serve(each,o.to).asRouter()
+    then: (_resolve, _error) => ready.then (()=>{
+      if (all.length === 0) return _resolve()
+      const response = all.length === 1 ? all[0] : {}
+      for (const each of all) {
+        Object.defineProperty (response, each.name, { enumerable:true, configurable:true, get(){
+          let chimera = each
+          if (each.definition && !each._is_dark) {
+            chimera = ProtocolAdapter.for (each)
+            Object.setPrototypeOf (chimera, each)
+            Object.defineProperty (chimera, 'name', { value: each.name })
+          }
+          Object.defineProperty (response, each.name, { enumerable:true, value: chimera })
+          return chimera
+        }})
       }
-      if (all.length === 1) {
-        response = Object.assign (all[0], response)
-      }
-      return resolve (response)
-    }, failed),
+      return _resolve (response)
+    }, _error),
 
     catch: (e) => ready.catch(e)
   }
@@ -140,6 +146,7 @@ async function _new (Service, d,m,o) {
       let service = cds.env.requires[srv.name]?.service
       if (service && !cds.services[service]) Object.defineProperty (cds.services, service, {value:srv})
     }
+    if (!o.silent) cds.emit (`serving:${srv.name}`, srv)
   })
   return srv
 }

package/lib/srv/middlewares/cds-context.js

@@ -0,0 +1,29 @@
+module.exports = ()=> {
+
+  const cds = require ('../../index')
+
+  /** @type { import('express').Handler } */
+  async function cds_context_provider (req, res, next) {
+    const ctx = new cds.EventContext
+    ctx.http = { req, res }
+    ctx.id = _id4(req)
+    ctx.user = req.user
+    ctx.tenant = req.tenant || ctx.user?.tenant
+    cds._context.run (ctx, next)
+  }
+
+  const { uuid } = cds.utils
+  const _id4 = (req) => {
+    let id = req.headers['x-correlation-id'] = (
+      req.headers['x-correlation-id'] ||
+      req.headers['x-correlationid'] ||
+      req.headers['x-request-id'] ||
+      req.headers['x-vcap-request-id'] ||
+      uuid()
+    )
+    req.res.set('X-Correlation-ID', id)
+    return id
+  }
+
+  return cds_context_provider
+}

package/lib/srv/middlewares/ctx-model.js

@@ -0,0 +1,24 @@
+module.exports = ()=>{
+  const cds = require ('../../index')
+  if (cds.requires.extensibility || cds.requires.toggles || cds.mtx) {
+    const { model4 } = require('../srv-models')
+    return async function cds_context_model (req,res, next) {
+      if (req.baseUrl.startsWith('/-/')) return next() //> our own tech services cannot be extended
+      const ctx = cds.context
+      if (ctx.tenant) try {
+        // if (req.headers.features) ctx.user.features = req.headers.features //> currently done in basic-auth only
+        ctx.model = req.__model = await model4 (ctx.tenant, ctx.features) // REVISIT: req.__model is because of Okra
+      } catch (e) {
+        console.error(e)
+        return res.status(503) .json ({ // REVISIT: we should throw a simple error, nothing else! -> this is overly OData-specific!
+          error: { code: '503', message:
+            process.env.NODE_ENV === 'production' ? 'Service Unavailable' :
+            'Unable to get context-specific model due to: ' + e.message
+          }
+        })
+      }
+      next()
+    }
+  }
+  else return []
+}

package/lib/srv/middlewares/errors.js

@@ -0,0 +1,9 @@
+module.exports = ()=> function cds_error_handler (err, req, res, next) {
+  // console.error (err)
+  // const n = Number(err.status || err.statusCode)
+  // res.status (n >= 400 && n < 600 ? n : 500)
+  // err.status = 400
+  // res.json ({ ...err, message: err.message, stack: err.stack })
+  // if (err.status === 401 && req.login) return req.login()
+  next (err)
+}

package/lib/srv/middlewares/index.js

@@ -0,0 +1,22 @@
+const auth      = exports.auth      = require('../../auth')
+const context   = exports.context   = require('./cds-context')
+const ctx_model = exports.ctx_model = require('./ctx-model')
+const errors    = exports.errors    = require('./errors')
+const trace     = exports.trace     = require('./trace')
+
+// middlewares running before protocol adapters
+exports.before = [
+  trace(),    // provides detailed trace logs when DEBUG=trace
+  auth(),     // provides req.user & tenant
+  context(),  // provides cds.context
+  ctx_model(),    // fills in cds.context.model
+]
+
+exports.after = [
+  // usually error middlewares
+  errors(),
+]
+
+exports.bootstrap = ()=>{
+  require('../protocols')()
+}

package/lib/srv/middlewares/sap-statistics.js

@@ -0,0 +1,13 @@
+const { performance:{now} } = require ('perf_hooks')
+
+module.exports = (prec = 1000) => function sap_statistics (req, res, next) {
+  if (req.query['sap-statistics'] || req.headers['sap-statistics']) {
+    const { writeHead } = res, t0 = now()
+    res.writeHead = function (...args) {
+      const total = ((now() - t0) / prec).toFixed(2)
+      if (res.statusCode < 400) res.setHeader('sap-statistics', `total=${total}`)
+      writeHead.call(this, ...args)
+    }
+  }
+  next()
+}

package/lib/srv/middlewares/trace.js

@@ -0,0 +1,102 @@
+const cds = require ('../../index'), { decodeURIComponent } = cds.utils
+const LOG = cds.log('trace')
+if (!LOG._debug) module.exports = ()=>[]; else {
+
+  module.exports = (o={}) => {
+
+    // normalize options
+    let { truncate:t = 111, skip = { BEGIN:1, COMMIT:2, ROLLBACK:3 } } = o || {}
+    if (typeof t !== 'function') o.truncate = !t ? s=>s : s => s.length <= t ? s : s.slice(0,t)+' ...'
+    if (typeof skip !== 'function') o.skip = !skip ? ()=>false : x => (x.event||x) in skip
+    const _perf = e => !o.skip(e) && cds.context?.http?.req._perf
+
+    // instrument framework services
+    _instrument_cds_services (_perf)
+    _instrument_better_sqlite (_perf)
+    _instrument_sqlite (_perf)
+
+    // the express middleware function
+    return function cap_perf_logger (req, res, next) {
+      let perf = req._perf || (req._perf = new PerfTrace)
+      perf.log (req.method, decodeURIComponent(req.originalUrl))
+      res.on('finish', ()=> LOG.debug ('elapsed times:', perf.toString(o)))
+      next()
+    }
+  }
+
+  const { performance:{now} } = require ('perf_hooks')
+  const { format } = require ('util')
+
+  class PerfTrace extends Array {
+    log (...details) {
+      const e = { details, start:now() }
+      return this.push(e), e
+    }
+    done (e) {
+      return e.stop = now()
+    }
+    toString ({truncate}) {
+      const t0 = this[0].start; if (!this[0].stop) this[0].stop = now()
+      return '\n'+ this.map (e => truncate (format (
+        (e.start - t0).toFixed(2).padStart(6), '→',
+        (e.stop  - t0).toFixed(2).padEnd(6), '= ',
+        (e.stop  - e.start).toFixed(2).padStart(6), 'ms',
+        '-', ...e.details))
+      ).join('\n')
+    }
+  }
+}
+
+
+function _instrument_cds_services (_get_perf) {
+  const me = _instrument_cds_services; if (me.done) return; else me.done = true
+  const { handle } = cds.Service.prototype
+  cds.Service.prototype.handle = function (req) {
+    const perf = _get_perf(req)
+    if (perf) {
+      const pe = perf.log (this.name, '-', req.event, req.path||'')
+      var _done = r => { perf.done(pe); return r }
+    }
+    return handle.apply (this, arguments) .then (_done)
+  }
+}
+
+function _instrument_sqlite (_get_perf) {
+  const me = _instrument_sqlite; if (me.done) return; else me.done = true
+  try { require.resolve('sqlite3') } catch { return }
+  // eslint-disable-next-line cds/no-missing-dependencies
+  const sqlite = require('sqlite3').Database.prototype
+  for (let each of ['all', 'get', 'run', 'prepare']) {
+    const _super = sqlite[each]
+    sqlite[each] = function (q, ..._) {
+      const perf = _get_perf(q)
+      if (perf) {
+        const pe = perf.log ('sqlite -', q)
+        const callback = _[_.length-1]; _[_.length-1] = function(){
+          perf.done(pe)
+          callback.apply (this, arguments)
+        }
+      }
+      return _super.call (this, q, ..._)
+    }
+  }
+}
+
+function _instrument_better_sqlite (_get_perf) {
+  const me = _instrument_better_sqlite; if (me.done) return; else me.done = true
+  try { require.resolve('better-sqlite3') } catch { return }
+  // eslint-disable-next-line cds/no-missing-dependencies
+  const sqlite = require('better-sqlite3').prototype
+  for (let each of ['exec', 'prepare']) {
+    const _super = sqlite[each]
+    sqlite[each] = function (q, ..._) {
+      const perf = _get_perf(q)
+      if (perf) {
+        const pe = perf.log ('sqlite -', q)
+        try { return _super.call (this, q, ..._) }
+        finally { perf.done(pe) }
+      }
+      else return _super.call (this, q, ..._)
+    }
+  }
+}

package/lib/srv/protocols/_legacy.js

@@ -0,0 +1,42 @@
+const libx = require('../../../libx/_runtime')
+const cds_context_model = require('../srv-models')
+const { ProtocolAdapter } = require('.')
+
+class LegacyProtocolAdapter extends ProtocolAdapter {
+
+  static init() {
+    return this.protocols = {
+      "odata": { get impl() { return libx.to.odata_v4 } },
+      "rest":  { get impl() { return libx.to.rest } },
+    }
+  }
+
+  static serve (srv, /* in: */ app) {
+    return super.serve (srv, app, { before: [
+      // async (req, res, next) => { await 1; next() }, // REVISIT: AsyncResource.bind() -> enable to break cds/tests/_runtime/odata/__tests__/integration/crud-with-mtx.test.js with existing, non-middleware mode, *w/o* fix to BufferedWriter
+      cap_req_logger,
+      libx.perf,
+      libx.auth(srv),
+      cds_context_model.middleware4(srv)
+    ], after:[] })
+  }
+
+}
+
+const cds = require('../../index')
+const LOG = cds.log(), DEBUG = cds.debug()
+function cap_req_logger (req,_,next) {
+  let url = req.originalUrl
+  try { url = decodeURI(req.originalUrl) } catch (e) { /* decodeURI throws error for invalid urls */ }
+  LOG && LOG (req.method, url, req.body||'')
+  if (/\$batch/.test(req.url))  req.on ('dispatch', (req) => {
+    let path = req._path
+    try { path = decodeURI(req._path) } catch (e) { /* decodeURI throws error for invalid urls */ }
+    LOG && LOG ('>', req.event, path, req._query||'')
+    if (DEBUG && req.query) DEBUG (req.query)
+  })
+  next()
+}
+
+LegacyProtocolAdapter.init()
+module.exports = LegacyProtocolAdapter

package/lib/srv/protocols/graphql.js

@@ -0,0 +1,39 @@
+const cds = require ('../../index'), { decodeURIComponent } = cds.utils
+const LOG = cds.log('graphql')
+
+const GraphQLAdapter = require('@sap/cds-graphql/lib') // eslint-disable-line cds/no-missing-dependencies
+const express = require ('express') // eslint-disable-line cds/no-missing-dependencies
+
+function CDSGraphQLAdapter (options) {
+
+  const {services} = options
+
+  return express.Router()
+  .use (express.json()) //> required in the slug handlers and logger below
+
+  /** Convenience slug route for /graphql/srv/entity/id */
+  .use ('/:path/:entity/:id?(%20:query)?', (req,_,next) => {
+    // TODO: add filter by id -> then remove the // eslint-disable-line
+    let { entity, id, query } = req.params // eslint-disable-line no-unused-vars
+    if (query) req.body = { query }
+    if (entity) req.body.query = req.body.query.replace(/{/, `{ ${entity} {`) +'}'
+    next() //> goes on below
+  })
+
+  /** Convenience slug route for /graphql/srv */
+  .use ('/:path', (req, res, next) => {
+    let srv = services [req.params.path]
+    if (req.body) req.body.query = req.body.query.replace(/{/, `{ ${srv.name} {`) +'}'
+    next() //> goes on below
+  })
+
+  .use ((req,_,next)=>{
+    LOG.info (req.method, req.body?.query || decodeURIComponent(req.query.query))
+    next()
+  })
+
+  /** The global /graphql route */
+  .use (new GraphQLAdapter (services, options))
+}
+
+module.exports = CDSGraphQLAdapter

package/lib/srv/protocols/hcql.js

@@ -0,0 +1,37 @@
+const cds = require('../../index'), { decodeURIComponent } = cds.utils
+const LOG = cds.log('hcql')
+const express = require('express') // eslint-disable-line cds/no-missing-dependencies
+
+module.exports = function HCQLAdapter (srv) {
+
+  return express.Router()
+  .use(express.json()) //> for application/json -> cqn
+  .use(express.text()) //> for text/plain -> cql -> cqn
+
+  /** Returns CSN schema in response to /<srv>/$csn requests */
+  .get('/\\$csn', (_, res) => {
+    let csn = cds.minify (cds.model, { service: srv.name })
+    res.json(csn)
+  })
+
+  /** Convenience route for REST-style request formats like that: */
+  .get('/:entity/:id?(%20:tail)?', (req, _, next) => {
+    let { entity, id, tail } = req.params, q = SELECT.from(entity, id)
+    if (is_string(req.body)) tail = req.body
+    else if (is_array(req.body)) q.columns(req.body)
+    else Object.assign(q.SELECT, req.body)
+    if (tail) q = { SELECT: { ...CQL(`SELECT from _ ${tail}`).SELECT, ...q.SELECT } }
+    req.body = q; next() // delegating to main handler
+  })
+
+  /** The actual protocol adapter. */
+  .use((req, res, next) => {
+    let q = req.body; if (is_string(q)) q = CQL(q)
+    LOG.info (req.method, decodeURIComponent(req.originalUrl), { ...q })
+    return srv.run(q).then(r => res.json(r)).catch(next)
+  })
+
+}
+
+const is_string = x => typeof x === 'string'
+const is_array = Array.isArray

package/lib/srv/protocols/index.js

@@ -0,0 +1,86 @@
+const cds = require('../../index')
+const {join} = cds.utils.path
+
+class ProtocolAdapter {
+
+  /**
+   * Provides canonicalized protocols configurations
+   */
+  static init (protocols = { ...cds.env.protocols }) {
+    for (let [k,o] of Object.entries(protocols)) if (typeof o === 'string') protocols[k] = {path:o}
+    if (!protocols.odata) protocols.odata = { impl: join(__dirname,'odata-v4') }
+    if (!protocols.rest) protocols.rest = { impl: join(__dirname,'rest') }
+    return this.protocols = protocols
+  }
+
+  /**
+   * Returns the middleware impl for the given protocol
+   */
+  static middlewareFor (p) {
+    const conf = this.protocols[p] || (this.protocols[p] = {})
+    let { impl = join(__dirname,p) } = conf; if (typeof impl !== 'function') {
+      try { require.resolve(impl) } catch { cds.error `Cannot find protocol adapter implementation: ${impl}` }
+      impl = conf.impl = require(impl)
+    }
+    return impl
+  }
+
+  /**
+   * Constructs a new adapter for the given service, or returns a formerly constructed one
+   */
+  static for (srv, p = srv.options?.to || protocol4(srv.definition)) {
+    const cache = srv._adapters || (srv._adapters={}); if (p in cache) return cache[p]
+    const impl = this.middlewareFor(p), conf = this.protocols[p]
+    return cache[p] = impl (srv, conf)
+  }
+
+  /**
+   * Constructs a new adapter for the given service, and mounts it to an express app.
+   */
+  static serve (srv, /* in: */ app, { before, after } = cds.middlewares) {
+    const adapter = this.for(srv); if (!adapter) return
+    app.use (srv.path+'/webapp/', (_,res) => res.sendStatus(404))
+    app.use (srv.path, before, adapter, after)
+    return adapter
+  }
+
+  /**
+   * Serve protocols at configured paths, if any; e.g. /hcql/browse, /graphql/...
+   */
+  static serveAll (protocols = Object.entries(ProtocolAdapter.protocols).filter(([,o]) => o.path)) {
+    if (protocols?.length) cds.once ('served', ()=>{
+      const LOG = cds.log(), DEBUG = cds.debug('adapters')
+      for (let [ protocol, options ] of protocols) {
+        let globalAdapter = false
+        for (let srv of cds.service.providers) {
+          if (!protocol4(srv.definition,null)) {
+            let adapter = ProtocolAdapter.middlewareFor(protocol); if (!adapter) continue
+            if (is_global(adapter)) { globalAdapter = adapter; break }
+            _serve (adapter(srv,options), options.path + srv.path, protocol, options)
+          }
+        }
+        if (globalAdapter) {
+          options = { ...options, services: cds.service.providers
+            .filter (srv => { let p = protocol4(srv.definition,null); return !p || p === protocol })
+            .reduce ((all,srv) => (all[srv.path.slice(1)] = srv, all), {})
+          }
+          _serve (globalAdapter(options), options.path, protocol, options)
+        }
+      }
+      function _serve (adapter, path, protocol, options) {
+        if (!_serve.first) { _serve.first = true; console.log() }
+        if (!_serve[protocol]) LOG.info ('serving', _serve[protocol] = { protocol, at: options.path })
+        DEBUG?.('app.use(', path, ', ... )')
+        cds.app.use (path, cds.middlewares.before, adapter, cds.middlewares.after)
+      }
+    })
+  }
+}
+
+
+const protocols = Object.keys(ProtocolAdapter.init())
+const protocol4 = (def, _default = protocols[0]) => def['@protocol'] || protocols.find(p => def['@'+p]) || _default
+const is_global = adapter => adapter.length === 1 && !/^(function )?(\w+\s+)?\((srv|service)/.test(adapter)
+
+module.exports = Object.assign (ProtocolAdapter.serveAll, { ProtocolAdapter, protocol4 })
+if (!cds.requires.middlewares) module.exports.ProtocolAdapter = require('./_legacy')