@sap/cds 7.9.2 → 8.0.3

package/lib/srv/srv-api.js

@@ -149,23 +149,3 @@ const is_rest = x => x && typeof x === 'string' && x[0] === '/'
 const is_query = x => x && x.bind || is_array(x) && !x.raw
 const is_array = (x) => Array.isArray(x) && !x.raw
 const is_object = (x) => typeof x === 'object'
-
-// Deprecated
-/** @deprecated: To be removed with the next major release */
-Service.prototype.stream = cds.utils.deprecated (function (...args) {
-  if (is_query(args[0])) {
-    Object.defineProperty(args[0], '_stream', { value: true, enumerable: false })
-    if (cds.env.features.stream_compat)
-      Object.defineProperty(args[0], '_streaming', { value: true, enumerable: false })
-    return this.run(...args).then(result => {
-      if (!result) return result
-      return Array.isArray(result) ? Object.values(result[0])[0] : Object.values(result)[0]})
-  }
-  const q = (args ? SELECT.one.columns(args) : SELECT.one).bind(this)
-  Object.defineProperty(q, '_stream', { value: true, enumerable: false })
-  if (cds.env.features.stream_compat) Object.defineProperty(q, '_streaming', { value: true, enumerable: false })
-  return q
-}, {
-  old: 'srv.stream()',
-  use: 'srv.read()'
-})

package/lib/srv/srv-dispatch.js

@@ -15,8 +15,9 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
   if (!this.context) return this.run (tx => tx.dispatch(req))
   if (!req.tx) req.tx = this // `this` is a tx from now on...
 
-  // Inform potential listeners // REVISIT: -> this should move into protocol adapters
-  let _is_root = req.constructor.name in { ODataRequest:1, RestRequest:2 }
+  // REVISIT: remove together with okra
+  // Inform potential listeners
+  let _is_root = req.constructor.name in { ODataRequest:1 }
   if (_is_root) req._.req.emit ('dispatch',req)
 
   // Handle batches of queries

package/lib/srv/srv-handlers.js

@@ -4,7 +4,13 @@ const LOG = cds.log()
 class EventHandlers {
 
   constructor (name) {
-    this._handlers = { _initial:[], before:[], on:[], after:[], _error:[] }
+    this._handlers = {
+      /** @type {EventHandler[]} */ _initial:[],
+      /** @type {EventHandler[]} */ before:[],
+      /** @type {EventHandler[]} */ on:[],
+      /** @type {EventHandler[]} */ after:[],
+      /** @type {EventHandler[]} */ _error:[]
+    }
     this.name = name
   }
 
@@ -68,9 +74,12 @@ const _register = function (srv, phase, event, path, handler) { //NOSONAR
     for (let each of ['CREATE','UPDATE']) _register (srv, phase, each, path, handler)
     return this
   }
-  else if (event === 'each' || phase === 'after' && /^\(?each\)?/.test(handler)) {
-    const h=handler; event = 'READ'
-    handler = (rows,req) => is_array(rows) ? rows.forEach (r => h(r,req)) : rows && h(rows,req)
+  else if (phase === 'after' && ( event === 'each'    //> srv.after ('each', Book, b => ...)    // event 'each' => READ each
+    || event === 'READ' && path?.is_singular          //> srv.after ('READ', Book, b => ...)    // Book is a singular def from cds-typer
+    || event === 'READ' && /^\(?each\b/.test(handler) //> srv.after ('READ', Book, each => ...) // handler's first param is named 'each'
+  )) {
+    event = 'READ' // override event='each' to 'READ'
+    const h=handler; handler = (rows,req) => is_array(rows) ? rows.forEach (r => h(r,req)) : rows && h(rows,req)
   }
   else if (typeof event === 'object') {
     // extract action name from an action definition's fqn
@@ -91,7 +100,7 @@ const _register = function (srv, phase, event, path, handler) { //NOSONAR
     if (!path.startsWith(srv.name+'.')) path = `${srv.name}.${path}`
   }
 
-  if (cds.env.fiori.lean_draft && cds.env.fiori.draft_compat) {
+  if (cds.env.fiori.draft_compat) {
     const entity = path && srv.model?.definitions[path.name || path]
     if (['PATCH', 'CANCEL', 'NEW'].includes(event)) {
       // delegate to drafts
@@ -120,14 +129,16 @@ class EventHandler {
     this.handler = handler
     Object.defineProperties (this, { // non-enumerable properties to improve debugging
       _initial: { value: handler._initial },
-      for: { value:
-        event && path ? (req) => (event === req.event) && (path === req.path || path === req.entity) :
-        event ? (req) => (event === req.event) :
-        path ? (req) => (path === req.path || path === req.entity) :
-        /* else: */ () => true
-      }
+      for: { value: this.for(event,path) }
     })
   }
+  /** Factory for the actual filter method this.for, assigned above */
+  for (event, path) {
+    if (event && path) return req => event === req.event && (path === req.path || path === req.entity)
+    if (event) return req => event === req.event
+    if (path) return req => path === req.path || path === req.entity
+    else return () => true
+  }
 }
 
 

package/lib/srv/srv-methods.js

@@ -67,7 +67,7 @@ const add_handler_for = (srv, def) => {
       req.params = [ args.shift() ]    // second argument is the target's primary key
     }
     const {params} = target ? target.actions[event] : def
-    if (params) req.data =  _named(args,params) || _positional(args,params)
+    if (params) req.data = _named(args,params) || _positional(args,params)
 
     // ensure legacy compat, keys in req.data
     if(cds.env.features.keys_in_data_compat && target) {
@@ -104,5 +104,5 @@ const _named = (args, declared) => {
 }
 
 const _positional = (args, declared) => Object.keys(declared).reduce (
-  (data,k,i) => { data[k] = args[i]; return data }, {}
+  (data,k,i) => { if (args[i] !== undefined) data[k] = args[i]; return data }, {}
 )

package/lib/srv/srv-models.js

@@ -2,10 +2,6 @@
 // REVISIT: all edmx caches also have to be hooked in here
 
 const cds = require ('../index')
-const LOG = cds.log()
-
-const {normalizeError} = require('../../libx/_runtime/common/error/frontend')
-const getError = require('../../libx/_runtime/common/error')
 
 /**
  * Implements a static cache for all tenant/features-specific models.
@@ -15,34 +11,6 @@ const getError = require('../../libx/_runtime/common/error')
  */
 class ExtendedModels {
 
-  /**
-   * Returns an express middleware to be used with the given srv to set cds.context.model.
-   * Uses `this.model4(...)` to get the respective tenant/features-specific models.
-   * @returns {(req,res)=>{}}
-   */
-  static middleware4 (srv) {
-    if (!(srv instanceof cds.ApplicationService)) return [] //> no middleware to add // REVISIT: move to `srv.isExtensible`
-    if (!srv.isExtensible) return [] //> no middleware to add
-    else return async function cds_context_model (req,res,next) {
-      if (!req.tenant && !req.user?.tenant && !req.features && !req.user?.features) return next()
-      const ctx = cds.context = cds.EventContext.for({ http: { req, res } })
-      ctx.user = req.user // REVISIT: should move to auth middleware?
-      try {
-        ctx.model = req.__model = await ExtendedModels.model4 (ctx.tenant, ctx.features)
-      } catch (e) {
-        LOG.error (Object.assign(e, { message: 'Unable to get service from service map due to error: ' + e.message }))
-
-        // return 503 to client
-        // REVISIT: Error handling!
-        const { error } = normalizeError(getError(Object.assign(e, { statusCode: 503 })), req)
-
-        return res.status(503).json({ error })
-      }
-      next()
-    }
-  }
-
-
   /**
    * Returns the model to use for given tenant and features.
    * Loaded models are cached, with eviction on inactivity of tenants,
@@ -87,7 +55,7 @@ class ExtendedModels {
    * @returns {string} of the form `<tenant>:<comma-separated-features>`
    */
   key4 (tenant, features) {
-    return `${tenant||''}:${features.$hash}`
+    return `${tenant||''}:${features?.$hash}`
   }
 
 
@@ -158,7 +126,7 @@ class ExtendedModels {
   }
 
 
-  /** The cache instance used by `middleware4()` and `model4()`. */
+  /** The cache instance used by `model4()`. */
   static cache = new ExtendedModels
 
   /** Time interval in ms to check for new extensions and refresh models, if so. */
@@ -176,7 +144,6 @@ module.exports = ExtendedModels
 const extensibility = cds.requires.extensibility
 if (!extensibility) {
   ExtendedModels.prototype.at = function (key) { return this[key] }
-  if (!cds.requires.toggles) ExtendedModels.middleware4 = ()=> []
 }
 
 
@@ -189,7 +156,7 @@ const _get_model4 = async (tenant, features) => {
   if (cds.edmxs) await cds.compile.to.edmx.files ( csn,
     // adding tenant and features to runtime model, for later use when fetching generated files
     nsn.tenant = tenant,
-    nsn.features = features.join()
+    nsn.features = features?.$hash
   )
   return nsn
 }

package/lib/test/expect.js

@@ -0,0 +1,343 @@
+const { inspect } = require('node:util')
+const format = x => inspect(
+  is.error(x) ? x.message
+  : typeof x === 'object' && 'status' in x && 'body' in x ? { status: x.status, body: x.body }
+  : typeof x === 'object' && 'status' in x && 'data' in x ? { status: x.status, data: x.data }
+  : x,
+  { colors: true, sorted: true, depth: 11 }
+)
+
+const expect = module.exports = actual => {
+  const chainable = function (x) { return this.call(x) }; delete chainable.length
+  return Object.setPrototypeOf(chainable, new Assertion(actual))
+}
+
+const is = new class {
+  Array = Array.isArray
+  Error = x => x instanceof Error || x?.stack && x.message
+  Symbol = x => typeof x === 'symbol'
+  Object = x => typeof x === 'object' // && x && !is.array(x)
+  String = x => typeof x === 'string' || x instanceof String
+  Number = x => typeof x === 'number' || x instanceof Number
+  Boolean = x => typeof x === 'boolean' || x instanceof Boolean
+  Promise = x => x instanceof Promise
+  RegExp = x => x instanceof RegExp
+  Date = x => x instanceof Date
+  Set = x => x instanceof Set
+  Map = x => x instanceof Map
+  array = this.Array
+  error = this.Error
+  symbol = this.Symbol
+  object = this.Object
+  string = this.String
+  number = this.Number
+  boolean = this.Boolean
+  promise = this.Promise
+  regexp = this.RegExp
+  date = this.Date
+  set = this.Set
+  map = this.Map
+  /** Jest-style any matcher */
+  any = expect.any = type => {
+    if (type === undefined) return () => true
+    else return this [type.name || type] || (x => x instanceof type)
+  }
+}
+
+
+class Core {
+
+  constructor (actual) { this._ = actual }
+
+  /** The central method to throw an AssertionError. */
+  expected ([a, be, ...etc], ...args) {
+    const raw = [a, (this._not ? ' NOT' : '') + be, ...etc]
+    const err = new expected({ raw }, ...args)
+    // err.operator = be.trim().replace(/^to /,'')
+    // err.expected = args[1]
+    // err.actual = args[0]
+    throw err
+  }
+
+  should ([be, ...etc], ...args) {
+    return this.expected(['', ' to ' + be, ...etc], this._, ...args)
+  }
+
+  /** The central method to check assertions. */
+  assert (check, _fail = () => false) {
+    const outcome = check(this._)
+    if (this._not ? outcome : !outcome) return _fail(outcome)
+    else return this
+  }
+
+  instanceof (x) {
+    return this.assert(a => a instanceof x) || this.should`be an instance of ${x.name || x}`
+  }
+
+  kindof (x) {
+    return this.assert(is.any(x)) || this.should`be kind of ${x?.name || x}`
+  }
+
+  equals (x, _fail = () => this.should`strictly equal ${x}`) {
+    if (typeof x === 'function') return this.assert(x)
+    if (this._deep) return this.eqls(x)
+    return this.assert(a => a === x, _fail)
+  }
+
+  eqls (x, _fail = () => this.should`deeply equal ${x}`) {
+    if (typeof x === 'function') return this.assert(x)
+    return this.assert(a => compare(a, x, true), _fail)
+  }
+
+  subset (x, _fail = () => this.should`contain subset ${x}`) {
+    return this.assert(a => {
+      if (is.array(a) && is.array(x)) return x.every(x => a.some(o => compare(o, x, false)))
+      if (is.array(a) && !is.array(x)) return a.some(o => compare(o, x, false))
+      else return compare(a, x, false)
+    }, _fail)
+  }
+
+  matches (x, _fail = () => this.should`match ${x}`) {
+    return this.assert(a => {
+      if (is.regexp(x)) return x.test(a)
+      if (is.string(x)) return a.includes?.(x)
+      if (is.object(x)) return this.subset(x) && !this._not //> to avoid doubled not
+      // if (is.array(x)) return x.every(x => a.includes(x))
+    }, _fail)
+  }
+
+  includes (x, _fail = () => this.should`include ${x}`) {
+    return this.assert(a => {
+      if (!a) expected`an array or string or set or object but got ${a}`
+      if (is.string(a)) return a.includes(x)
+      if (is.array(a)) return a.includes(x) || this._deep && a.some(o => compare(o, x, true))
+      if (is.set(a)) return a.has(x)
+      if (this._deep && is.object(a)) return compare(a, x, true)
+    }, _fail)
+  }
+
+  oneOf (x, _fail = () => this.should`be one of ${x}`) {
+    return this.assert(a => x.includes(a), _fail)
+  }
+
+  throws (x, _fail = () => this.should`throw ${x}`) {
+    if (is.promise(this._)) return this.rejectsWith(x)
+    return this.assert(a => {
+      if (typeof a === 'function') try { a(); return false } catch (err) { if (!x) return true; else a = err }
+      if (typeof x.test === 'function') return x.test(a)
+      if (typeof x === 'function') return x(a)
+      if (typeof x === 'string') return a == x || a.code == x || a.message?.includes(x)
+      if (typeof x === 'object') return compare(a, x, false)
+    }, _fail)
+  }
+
+  rejectsWith (x) {
+    if (this._not) return Promise.resolve(this._).catch(
+      e => expected`promise to be fulfilled but it was rejected with ${e}`
+    )
+    else return Promise.resolve(this._).then(
+      y => expected`promise to be rejected but it was fulfilled with ${y}`,
+      e => {
+        if (x) expect(e).throws(x, () => expected`promise to be rejected with ${x} but got ${e}`)
+        return e
+      }
+    )
+  }
+
+  length (ln) {
+    return this.assert(a => (a.length ?? String(a).length) === ln, () => this.should`have length ${ln}`)
+  }
+
+  property (p, v) {
+    const has = !this._own ? (a, p) => p in a : Reflect.getOwnPropertyDescriptor
+    const get = (a, p) => has(a, p) ? a[p] : $not_found, $not_found = {}
+    const y = this.assert(() => true) && !this._nested ? get(this._, p) : p.split('.').reduce((a, p) => get(a, p), this._)
+    if (y === $not_found) return this._not || (this._nested
+      ? this.should`have nested property ${p}`
+      : this.should`have property ${p}`)
+    const that = Object.assign(expect(), this, { _: y })
+    if (v !== undefined) return that.eqls(v, () => this._nested
+      ? this.should`have nested property ${p} with value ${v}`
+      : this.should`have property ${p} with value ${v}`)
+    return that
+  }
+
+  keys (...keys) {
+    if (is.array(keys[0])) keys = keys[0]
+    return this.assert(a => keys.every(k => k in a)) || this.should`have all keys ${keys}`
+  }
+
+  gt (x) { return this.assert(a => a > x) || this.should`be > ${x}` }
+  lt (x) { return this.assert(a => a < x) || this.should`be < ${x}` }
+  gte (x) { return this.assert(a => a >= x) || this.should`be >= ${x}` }
+  lte (x) { return this.assert(a => a <= x) || this.should`be <= ${x}` }
+  within (x, y) { return this.assert(a => x <= a && a <= y) || this.should`be within ${[x, y]}` }
+}
+
+
+class Chai extends Core {
+
+  // linguistic chaining
+
+  get to () { return this }
+  get be () { this.call = this.equals; return this }
+  get is () { this.call = this.equals; return this }
+  get at () { return this }
+  get of () { return this }
+  get and () { return this }
+  get but () { return this }
+  get has () { this.call = this.property; return this }
+  get have () { this.call = this.property; return this }
+  get that () { return this }
+  get does () { return this }
+  get with () { return this }
+  get also () { return this }
+  get still () { return this }
+  get which () { return this }
+  get eventually () {
+    this.assert = (fn, _fail) => Promise.resolve(this._).then(a => expect(a).assert(fn, _fail))
+    return this
+  }
+
+  // flags changing behaviour of subsequent methods in the chain
+
+  get not () { this._not = true; return this }
+  get own () { this._own = true; return this }
+  get deep () { this._deep = true; return this }
+  get nested () { this._nested = true; return this }
+  get ordered () { return unsupported() }
+  get any () { return unsupported() }
+  get all () { return this }
+
+  get undefined () { return this.assert(a => a === undefined) || this.should`be undefined` }
+  get exist () { return this.assert(a => a != undefined) || this.should`exist` }
+  get truthy () { return this.assert(a => !!a) || this.should`be truthy` }
+  get falsy () { return this.assert(a => !a) || this.should`be falsy` }
+  get null () { return this.assert(a => a === null) || this.should`be ${null}` }
+  get true () { return this.assert(a => a === true) || this.should`be ${true}` }
+  get false () { return this.assert(a => a === false) || this.should`be ${false}` }
+  get empty () { return this.assert(a => !a?.length === 0 || Object.keys(a).length === 0) || this.should`be empty` }
+  get NaN () { return this.assert(a => isNaN(a)) || this.should`be ${NaN}` }
+  get ok () { return this.truthy }
+
+  get containSubset () { return this.subset }
+  get contains () { return this.includes }
+  get contain () { return this.includes }
+  get include () { return this.includes }
+  get match () { return this.matches }
+  get equal () { return this.equals }
+  get eq () { return this.equals }
+  get eql () { return this.eqls }
+  get exists () { return this.defined }
+  get lengthOf () { return this.length }
+  get instanceOf () { return this.instanceof }
+  get kindOf () { return this.kindof }
+  get kind () { return this.kindof }
+  get an () { this.call = this.kindof; return this }
+  get a () { this.call = this.kindof; return this }
+  get key () { return this.keys }
+
+  get below () { return this.lt }
+  get above () { return this.gt }
+  get most () { return this.lte }
+  get least () { return this.gte }
+  get lessThan () { return this.lt }
+  get greaterThan () { return this.gt }
+  get lessThanOrEqual () { return this.lte }
+  get greaterThanOrEqual () { return this.gte }
+
+  get throw () { return this.throws }
+  get fulfilled () { return this.not.rejectsWith() }
+  get rejected () { return this.rejectsWith() }
+  get rejectedWith () { return this.rejectsWith }
+}
+
+
+class Jest extends Chai {
+
+  get rejects () { return this }
+  get toBe () { return this.equals }
+  get toEqual () { return this.eqls }
+  get toMatch () { return this.matches }
+  get toMatchObject () { return this.matches }
+  get toContain () { return this.includes }
+  get toThrow () { return this.throws }
+  get toThrowError () { return this.throws }
+  get toBeGreaterThan () { return this.gt }
+  get toBeLessThan () { return this.lt }
+  get toBeGreaterThanOrEqual () { return this.gte }
+  get toBeLessThanOrEqual () { return this.lte }
+  get toHaveProperty () { return this.nested.property }
+  get toHaveLength () { return this.length }
+
+  toBeFalsy () { return this.falsy }
+  toBeTruthy () { return this.truthy }
+  toBeDefined () { return this.defined }
+  toBeUndefined () { return this.undefined }
+  toBeInstanceOf () { return this.instanceof }
+  toMatchSnapshot () { unsupported('toMatchSnapshot') }
+
+  static expect() {
+    expect.stringMatching = x => a => (is.regexp(x) ? x : RegExp(x)).test?.(a)
+    expect.arrayContaining = x => a => x.every(e => a.includes(e))
+    expect.any = is.any
+  }
+}
+Jest.expect()
+
+
+class Assertion extends Jest {
+  toString() { return `[ expect: ${format(this._)} ]` }
+}
+
+
+class AssertionError extends Error {
+  constructor (m, caller = Assertion.prototype.should) { Error.captureStackTrace (super(m), caller) }
+  get caller() { return Assertion.prototype.should }
+  get code() { return 'ERR_ASSERTION' }
+}
+
+// function AssertionError(m){
+//   Error.captureStackTrace (this,this.caller)
+//   this.message = m
+// }
+// AssertionError.prototype = Object.create (Error.prototype, {constructor:{value: AssertionError }})
+// AssertionError.__proto__ = Error
+
+
+expect.fail = function (actual, expected, message) {
+  if (arguments.length === 1) throw new AssertionError (actual, expect.fail)
+  if (arguments.length === 3) throw Object.assign (new AssertionError (message, expect.fail), { expected, actual })
+}
+
+function expected (strings, ...args) {
+  const err = new AssertionError ('expected ' + String.raw(strings, ...args.map(format)))
+  if (new.target) return err; else throw err
+}
+
+function unsupported (method) {
+  const ignore = unsupported.skip ??= (process.env._chest_skip || '')?.split(',').reduce((p, c) => (p[c] = 1, p), {})
+  if (!method) return new Error(`unsupported`)
+  if (method in ignore) return () => { }
+  else throw new Error(`
+    Method expect .${method}() is not yet supported.
+    Use --skip ${method} to skip checks.
+  `)
+}
+
+function compare (a, b, strict) {
+  if (a == b) return true
+  return function _recurse (a, b) {
+    if (!a || typeof a !== 'object') return false
+    if (!b || typeof b !== 'object') return false
+    if (strict)
+      for (let k of Object.keys(a)) if (!(k in b))
+        return false
+    for (let k in b) {
+      const v = a[k], x = b[k]; if (v === x) continue
+      if (typeof x === 'function') { if (x(v)) continue; else return false }
+      if (!_recurse(v, x)) return false
+    }
+    return true
+  }(a, b)
+}

package/lib/test/index.js

@@ -0,0 +1,2 @@
+// we might move cds-test.js here, but for now we just re-export it
+module.exports = require('../utils/cds-test')