@sap/cds 7.7.3 → 7.8.0

package/lib/linked/entities.js

@@ -1,40 +1,47 @@
-const cds = require('../')
-const { struct } = require ('./classes')
+const { LinkedDefinitions, struct, type } = require ('./classes')
+const _is_cached = Symbol('is cached')
+const _derived = Symbol('derived')
 
-class entity extends struct   {
+
+class entity extends struct {
   is (kind) { return kind === 'entity' || kind === 'view' && !!this.query || super.is(kind) }
   get keys() {
-    return this.own('_keys') || this.set('_keys', this._elements (e => e.key))
+    return this._elements ('key')
   }
   get associations() {
-    return this.own('_associations') || this.set('_associations', this._elements (e => e instanceof Association))
+    return this._elements ('isAssociation')
   }
   get compositions() {
-    return this.own('_compositions') || this.set('_compositions', this._elements (e => e instanceof Composition))
+    return this._elements ('isComposition')
+  }
+  _elements (kind, _default = null) {
+    const derived = this.own(_derived, ()=>({}))
+    if (kind in derived) return derived[kind]
+    const {elements} = this, dict = new LinkedDefinitions; let any = _default
+    for (let e in elements) if (elements[e][kind]) (any = dict)[e] = elements[e]
+    return derived[kind] = any
   }
+
   get drafts() {
     // Remove this getter when old draft is removed
-    if (cds.env.fiori.lean_draft) return null
     return this.own('_drafts') || this.set('_drafts', this.elements?.HasDraftEntity && {
       name: this.name + '_drafts', keys: this.keys,
       toString(){ return this.name.replace(/\./g,'_') }
     })
   }
+
+  toJSON() {
+    return this.own('query') ? {...this} : super.toJSON(this)
+  }
   toString() {
     return this.name.replace(/\./g,'_')
   }
-  _elements (filter) {
-    const {elements} = this, dict={}; let any
-    for (let e in elements) if (filter(elements[e])) (any = dict)[e] = elements[e]
-    return any
-  }
 }
 
 
-class Association extends struct {
+class Association extends type {
 
   is(kind) { return kind === 'Association' || super.is(kind) }
-  get isAssociation(){ return true }
 
   get is2many() { return !this.is2one }
   get is2one() {
@@ -45,11 +52,13 @@ class Association extends struct {
   set foreignKeys(k) { this.set('foreignKeys', k) }
   get foreignKeys() {
     const keys = this.keys; if (!keys) return this.foreignKeys = undefined
-    const foreignKeys = {}
+    const foreignKeys = new LinkedDefinitions
     for (const k of keys) {
       const el = k.ref.reduce((target,n)=> target.elements[n], this._target)
-      const as = k.as || k.ref[k.ref.length-1]
-      foreignKeys [as] = el.name === as ? el : { __proto__:el, name:as }
+      const as = k.as || k.ref.at(-1)
+      foreignKeys[as] = Object.create (el, { name:{value:as} }) //, parent:{value:this} })
+      // REVISIT: We should change the line above to set parent correctly, as in the commented tail part.
+      // But that breaks code in _runtime which expects it to be the wrong parent.
     }
     return this.foreignKeys = foreignKeys
   }
@@ -106,19 +115,14 @@ class Association extends struct {
         return value
       }
     }
-    else return super.dataIn (d,prefix)
+    else return struct.prototype.dataIn.call (this, d, prefix)
   }
 }
-const _is_cached = Symbol('_cached')
-
 
 class Composition extends Association {
 
   is(kind) { return kind === 'Composition' || super.is(kind) }
-  get isComposition(){ return true }
-  get isManagedComposition(){ return this._target && this._target.kind !== 'entity' }
 
 }
 
-
 module.exports = { entity, Association, Composition }

package/lib/linked/models.js

@@ -1,28 +1,45 @@
-const { types, classes:{ service, entity, action, event, any, struct, array, context, annotation } } = require('./types')
-const _kinds = { annotation, context, service, action, event, entity, view:entity }
+const { types, classes } = require('./types')
+const { LinkedDefinitions, any } = classes
+const _kinds = {
+  annotation:1,
+  context:1,
+  service:1,
+  entity:1,
+  action:1,
+  event:1
+}
+
 
-class LinkedCSN extends any {
+class LinkedCSN {
 
   constructor(x) {
-    const defs = x.definitions; for (let d in defs) _link (defs[d],d)
+
+    if (typeof x === 'string') x = require('../index').compile(x) //> for convenience in repl
+    const defs = x.definitions = _iterable (x.definitions)
+    for (let d in defs) _link (defs[d],d)
+    return Object.setPrototypeOf (x, new.target.prototype)
+
     function _link (d, name, parent, _kind) {
       if (name)     _set (d,'name', name)
       if (parent) { _set (d,'parent', parent); if (!d.kind) _set (d,'kind', _kind || 'element') }
-      if (d.kind === 'service') { for (let e in defs) if (e.startsWith(name+'.')) _set (defs[e],'_service',d) }
+      if (d.kind === 'service') {
+        for (let e in defs) if (e.startsWith(name+'.')) _set (defs[e],'_service',d)
+        _set (d,'model',x) //> required for getters like service.entities
+      }
       else if (d.target)          _set (d,'_target', _target(d.target) || _link (d.target,name,d))
       else if (d.projection)      _set (d,'query', {SELECT:d.projection})
       else if (d.returns)         _link (d.returns)
       else if (d.items)           _link (d.items)
-      for (let e in d.elements)   _link (d.elements[e],e,d)
-      for (let a in d.actions)    _link (d.actions[a],a,d,'action')
-      for (let p in d.params)     _link (d.params[p],p,d,'param')
+      for (let e in _iterable(d.elements)) _link (d.elements[e],e,d)
+      for (let a in _iterable(d.actions))  _link (d.actions[a],a,d,'action')
+      for (let p in _iterable(d.params))   _link (d.params[p],p,d,'param')
       let p = (                   //> determine the definition's prototype ...
         d.type            ? _typeof (d.type) || _resolve (d.type) :
-        d.query           ? _infer (d.query, defs) || _not_inferred :
-        d.kind in _kinds  ? _kinds[d.kind].prototype :
-        d.elements        ? struct.prototype :
-        d.items           ? array.prototype :
-        /* else: */         any.prototype
+        d.query           ? _infer (d.query, defs) || types.entity :
+        d.kind in _kinds  ? types[d.kind] :
+        d.elements        ? types.struct :
+        d.items           ? types.array :
+        /* else: */         types.any
       )
       if (d.kind === 'entity') {
         if (p.actions && !d.actions) _set (d,'actions',undefined) //> don't propagate .actions
@@ -49,7 +66,6 @@ class LinkedCSN extends any {
         if (!t) return
       }
     }}
-    return Object.setPrototypeOf (x, new.target.prototype)
   }
 
   *each (x, defs=this.definitions) {
@@ -79,39 +95,44 @@ class LinkedCSN extends any {
     return this
   }
 
-  childrenOf (x, filter=()=>true, defs = this.definitions) {
-    const ns = !x ? false : typeof x === 'string' ? x : x.namespace || x.name, prefix = ns ? ns+'.' : ''
-    const children = (ns) => !ns ? children : this.childrenOf (ns,filter)
+  childrenOf (x, filter = ()=>true, defs = this.definitions) {
+    const children = namespace => !namespace ? children : this.childrenOf (namespace,filter)
+    const prefix = !x ? '' : typeof x === 'string' ? x+'.' : ((x = x.namespace || x.name)) ? x+'.' : ''
     for (let fqn in defs) if (fqn.startsWith(prefix)) {
-      const d = defs[fqn], name = fqn.slice(prefix.length)
-      if (filter(d,name)) { children[name] = d
-        if (d.is('entity') && fqn.endsWith('.texts')) { // REVISIT: to bridge transition to cv2 only
-          const _texts = defs [fqn.slice(0,-6)+'_texts']
-          if (_texts) _set (children, name.slice(0,-6)+'_texts', d) // REVISIT: last arg should be _texts but runtime tests fail with that
-        }
-      }
+      const d = defs[fqn]; if (!filter(d)) continue
+      else children[fqn.slice(prefix.length)] = d
+      if (d.is_entity && fqn.endsWith('.texts')) _set (children, fqn.slice(prefix.length,-6)+'_texts', d)
     }
-    return _set (children, Symbol.iterator, function*(){ for (let e in this) yield this[e] })
+    return _iterable (children)
   }
 
-  get exports()  { return this.set ('exports',  this.childrenOf (this, (_,rn)=>!rn.includes('.'))) }
-  get entities() { return this.set ('entities', this.childrenOf (this, d => d instanceof entity)) }
-  get services() { return this.set ('services', this.all('service')) }
+  get exports()  { return this.set ('exports',  this.childrenOf (this)) }
+  get entities() { return this.set ('entities', this.childrenOf (this, d => d.is_entity)) }
+  get services() {
+    let srvs = this.all (d => d.is_service)
+    for (let s of srvs) Object.defineProperty (srvs, s.name, {value:s})
+    return this.set ('services', srvs)
+  }
 }
 
 
-const _unresolved = (x,unknown=any) => ({ name:x, __proto__:unknown.prototype, _unresolved:true })
-const _builtin = x => types[x] || typeof x === 'string' && x.startsWith('cds.hana.') && any.prototype
-const _infer = require('../ql/infer'), _not_inferred = _unresolved('<query>',entity)
-const _set = (o,p,v) => Object.defineProperty (o,p,{value:v,enumerable:false,configurable:1,writable:1})
+const _iterable = defs => defs && Object.setPrototypeOf (defs, LinkedDefinitions.prototype)
+const _unresolved = (x, unknown = types.any) => ({ name:x, __proto__:unknown, _unresolved:true })
+const _builtin = x => types[x] || x.startsWith?.('cds.hana.') && types.any
+const _infer = require('../ql/infer')
+const _set = (o,p,v,e=false) => Object.defineProperty (o,p,{ value:v, enumerable:e, configurable:1, writable:1 })
 const _own = (o,p) => { const pd = Reflect.getOwnPropertyDescriptor(o,p); return pd && pd.value }
 const _is = x => {
   if (typeof x === 'string')  return x === 'any' ? ()=>true : d => d.is(x)
-  if (typeof x === 'function') return x.prototype instanceof any ? d => d instanceof x : x
+  if (typeof x === 'function') return x.prototype?.is_linked ? d => d instanceof x : x
   throw new Error ('invalid filter for model reflection: '+ x)
 }
 
+
+_set (LinkedCSN.prototype, 'set', any.prototype.set) //> inherit this.set() from any
+LinkedCSN.prototype.set('is_linked', true)
+any.prototype.set('is_linked', true)
+
+
 /** @returns {LinkedCSN} */
-module.exports = x => x instanceof any ? x : new LinkedCSN (
-  typeof x === 'string' ? require('../index').compile(x) : x
-)
+module.exports = Object.assign (x => x.is_linked ? x : new LinkedCSN (x), { LinkedCSN, LinkedDefinitions, types, classes })

package/lib/linked/types.js

@@ -1,116 +1,54 @@
-/*
-	This is the inner core of cds: its type system, bootstrapped from in-place
-	CSN models itself. Besides the actual root types, a set of common and
-	recommended scalar types is added to builtin.types.
-*/
-const classes = Object.assign (
+
+const classes = exports.classes = Object.assign (
 	require('./classes'),
 	require('./entities'),
 )
 
-
-/** Type system roots -> can be used with instanceof */
-const roots = _roots ({
-	any: classes.any.prototype,
-	type: {},
-		scalar: {type:'type'},
-			string: {type:'scalar'},
-			number: {type:'scalar'},
-			boolean: {type:'scalar'},
-			date: {type:'scalar'},
-		array: {type:'type'},
-		struct: {type:'type'},
-			aspect: {type:'struct'},
-			entity: {type:'struct'},
-			event: {type:'struct'},
-	Association: {type:'type'},
-	Composition: {type:'Association'},
-	context: {},
-	service: {type:'context'},
-	$self: {}, //> to support polymorphic self links like in: action foo( self: [many] $self, ...)
-})
-
-/**
- * Turns the given CSN definitions into linked definitions with classes.
- * @type <T>(csn:T) => T
- */
- function _roots (defs) {
-	const linked = { any: classes.any.prototype }
-	for (const t in defs) {
-		if (t in classes) linked[t] = classes[t].prototype
-		else {
-			const c = class extends classes[defs[t].type || 'any'] {}
-			classes[t] = Object.defineProperty (c, 'name', {value:t})
-			linked[t] = Object.defineProperty (c.prototype, 'name', {value:t})
-		}
-	}
-	return linked
+const protos = { $self: new classes.any } //> to support polymorphic self links like in: action foo( self: [many] $self, ...)
+const types = exports.types = {__proto__:protos}
+for (let k in classes) if (k !== 'LinkedDefinitions' && k !== 'mixins') {
+	const t = protos[k] = classes[k].prototype, k2 = 'cds.'+k
+	if (k < 'a') Object.defineProperty (t, 'name', {value:k})
+	if (k < 'a') Object.defineProperty (types[k2] = t, '_type', {value:k2})
 }
 
 
-/** Construct builtin.types as dictionary of all roots and common types */
-const types = _common ({ __proto__: roots,
-	UUID: {type:'string',length:36,isUUID:true},
-	String: {type:'string'}, LargeString: {type:'String'},
-	Binary: {type:'string'}, LargeBinary: {type:'Binary'},
-	Boolean: {type:'boolean'},
-	Integer: {type:'number'},
-		UInt8: {type:'Integer'},
-		Int16: {type:'Integer'}, Integer16: {type:'Int16'},
-		Int32: {type:'Integer'}, Integer32: {type:'Int32'},
-		Int64: {type:'Integer'}, Integer64: {type:'Int64'},
-	Float: {type:'number'},
-	Double: {type:'Float'},
-	Decimal: {type:'Float'}, DecimalFloat: {type:'Decimal'},
-	Date: {type:'date'},
-	Time: {type:'date'},
-	DateTime: {type:'date'},
-	Timestamp: {type:'DateTime'},
-	Vector: {type:'Binary'},
+Object.assign (protos, types.deprecated = {
+	'cds.DecimalFloat': Object.defineProperty (new classes.Decimal, '_type', { value:'cds.DecimalFloat' }),
+	'cds.Integer16': 		new classes.Int16,
+	'cds.Integer32': 		new classes.Int32,
+	'cds.Integer64': 		new classes.Int64,
 })
 
-/**
- * Link all definitions, essentially by: d.__proto__ = resolved (d.type),
- * and prefixes all common types with a namespace 'cds'.
- * @type <T>(csn:T) => T & roots
- */
-function _common (defs) {
-	const prefixed = {__proto__:defs}
-	for (let [name,d] of Object.entries(defs)) {
-		defs[name] = Object.defineProperty({ ...d, __proto__: defs[d.type] }, 'name', {value:name})
-		Object.defineProperty (prefixed['cds.'+name] = defs[name], '_type', {value:'cds.'+name})
-	}
-	for (let name of ['Association','Composition']) {
-		Object.defineProperty (prefixed['cds.'+name] = defs[name], '_type', {value:'cds.'+name})
-	}
-	return prefixed
-}
 
-;(
-	/**
-	 * Adds convenience functions which can be used like that:
-	 * ```js
-	 * var { Date, Time, DateTime } = cds.builtin.types
-	 * DateTime.now()   //> 2023-02-10T14:41:36.218Z
-	 * Date.now()       //> 2023-02-10T14:41:36.218Z
-	 * Time.now()       //> 14:43:18
-	 * Date.today()     //> 2023-02-10
-	 * ```
-	 */
-	function _add_convenience_functions(){
-		Object.defineProperties (types.Date, {
-			today: { value: ()=> (new Date).toISOString().slice(0,10) },
-			now: { value: ()=> (new Date).toISOString() },
-		})
+protos.service.set('is_service',true)
+protos.struct.set('is_struct',true)
+protos.entity.set('is_entity',true)
+protos.Association.set('isAssociation',true)
+protos.Composition.set('isComposition',true)
+protos.UUID.set('isUUID',true)
+protos.UUID.set('length',36)
 
-		Object.defineProperties (types.Time, {
-			now: { value: ()=> (new Date).toISOString().slice(11,19) },
-		})
 
-		Object.defineProperties (types.DateTime, {
-			now: { value: ()=> (new Date).toISOString() },
-		})
-	}
-)()
-
-module.exports = { types, classes }
+/**
+ * Adds convenience functions which can be used like that:
+ * ```js
+ * var { Date, Time, DateTime } = cds.builtin.types
+ * DateTime.now()   //> 2023-02-10T14:41:36.218Z
+ * Date.now()       //> 2023-02-10T14:41:36.218Z
+ * Time.now()       //> 14:43:18
+ * Date.today()     //> 2023-02-10
+ * ```
+ */
+function _add_convenience_functions(){
+	Object.defineProperties (types.Date, {
+		today: { value: ()=> (new Date).toISOString().slice(0,10) },
+		now: { value: ()=> (new Date).toISOString() },
+	})
+	Object.defineProperties (types.Time, {
+		now: { value: ()=> (new Date).toISOString().slice(11,19) },
+	})
+	Object.defineProperties (types.DateTime, {
+		now: { value: ()=> (new Date).toISOString() },
+	})
+}; _add_convenience_functions()

package/lib/ql/Whereable.js

@@ -44,9 +44,9 @@ class Query extends require('./Query') {
     if (typeof key !== 'object') key = { [Object.keys(this._target.keys||{ID:1})[0]]: key }
     if (this.SELECT) this.SELECT.one = true
     if (cds.env.features.keys_into_where) return this.where(key)
-    if (this.UPDATE) { this.UPDATE.entity = { ref: [{ id: this.UPDATE.entity, where: predicate4([key]) }] }; return this }
-    if (this.SELECT) { this.SELECT.from.ref[this.SELECT.from.ref.length-1] = { id: this.SELECT.from.ref[this.SELECT.from.ref.length-1], where: predicate4([key]) }; return this }
-    if (this.DELETE) { this.DELETE.from = { ref: [{ id: this.DELETE.from, where: predicate4([key]) }] }; return this }
+    if (this.UPDATE) { this.UPDATE.entity = { ref: [{ id: cds.env.ql.quirks_mode ? this.UPDATE.entity : this.UPDATE.entity.ref.at(-1), where: predicate4([key]) }] }; return this }
+    if (this.SELECT) { this.SELECT.from.ref[this.SELECT.from.ref.length-1] = { id: this.SELECT.from.ref.at(-1), where: predicate4([key]) }; return this }
+    if (this.DELETE) { this.DELETE.from = { ref: [{ id: cds.env.ql.quirks_mode ? this.DELETE.from : this.DELETE.from.ref.at(-1), where: predicate4([key]) }] }; return this }
     return this.where(key)
   }
 }

package/lib/req/context.js

@@ -3,6 +3,10 @@ const async_events = { succeeded:1, failed:1, done:1, commit:1 }
 const req_locale = require('./locale')
 const { EventEmitter } = require('events')
 
+// getter functions extracted to show deprecation warning only once
+const _getTenant = req => req.tenant
+const _getLocale = req => req.locale
+
 /**
  * This is the base class for `cds.Events` and `cds.Requests`,
  * providing the transaction context nature to all instances.
@@ -95,11 +99,11 @@ class EventContext {
       if (pd?.value) this[p] = pd.value
     }
     let user = u instanceof cds.User ? Object.create(u,{
-      tenant: {get:()=> cds.utils.deprecated (() => this.tenant, {kind: 'Property', old: 'req.user.tenant', use: 'req.tenant'})()},
-      locale: {get:()=> cds.utils.deprecated (() => this.locale, {kind: 'Property', old: 'req.user.locale', use: 'req.locale'})()},
+      tenant: {get:()=> cds.utils.deprecated (_getTenant, {kind: 'Property', old: 'req.user.tenant', use: 'req.tenant'})(this)},
+      locale: {get:()=> cds.utils.deprecated (_getLocale, {kind: 'Property', old: 'req.user.locale', use: 'req.locale'})(this)},
     }) : Object.defineProperties (new cds.User(u), {
-      tenant: {get:()=> cds.utils.deprecated (() => this.tenant, {kind: 'Property', old: 'req.user.tenant', use: 'req.tenant'})()},
-      locale: {get:()=> cds.utils.deprecated (() => this.locale, {kind: 'Property', old: 'req.user.locale', use: 'req.locale'})()},
+      tenant: {get:()=> cds.utils.deprecated (_getTenant, {kind: 'Property', old: 'req.user.tenant', use: 'req.tenant'})(this)},
+      locale: {get:()=> cds.utils.deprecated (_getLocale, {kind: 'Property', old: 'req.user.locale', use: 'req.locale'})(this)},
     })
     super.user = user
   }

package/lib/srv/protocols/hcql.js

@@ -1,5 +1,6 @@
 const express = require('express') // eslint-disable-line cds/no-missing-dependencies
 const cds = require('../../index')
+const { inspect } = require('util')
 
 class HCQLAdapter extends require('./http') {
 
@@ -34,7 +35,7 @@ class HCQLAdapter extends require('./http') {
      */
     .use((req, res, next) => {
       let q = this.query4(req)
-      this.log(req,q)
+      this.logger.info (req.method, decodeURIComponent(req.originalUrl), inspect(q,{colors:true,depth:11}))
       return srv.run(q).then(r => res.json(r)).catch(next)
     })
   }

package/lib/srv/protocols/http.js

@@ -1,32 +1,32 @@
 const express = require('express') // eslint-disable-line cds/no-missing-dependencies
 const cds = require('../../index')
-const { inspect } = require('util')
 
 
 module.exports = class HttpAdapter {
 
   constructor (srv) {
     this.kind = this.constructor.name.replace(/Adapter$/,'').toLowerCase()
-    this.log = cds.log (this.kind)
+    this.logger = cds.log (this.kind)
     return this.router4 (srv)
   }
 
   router4 (srv) {
     return express.Router()
+    .use(function req_logger(req,res,next) {
+      // this.log expected to be implemented by subclass
+      this?.log?.(req)
+      next()
+    }.bind(this))
     .use(this.early_access_check4(srv))
   }
 
-  log (req, cqn) {
-    this.log.info (req.method, decodeURIComponent(req.originalUrl), inspect(cqn,{colors:true,depth:11}))
-  }
-
   /** Does early checks on required roles to reject early */
   early_access_check4 (srv) {
 
     // Resolve required roles statically once....
     const d = srv.definition
     const roles = d['@requires'] || d['@restrict']?.map(r => r.to).flat()
-    || cds.env.requires.auth?.restrict_all_services !== false && ['authenticated-user']
+    || cds.env.requires.auth?.restrict_all_services !== false && process.env.NODE_ENV === 'production' && ['authenticated-user']
 
     // ... and return a handler function accordingly -> PROBLEM: Extensibility
     if (!roles) return (req, res, next) => next() //> no handlers required

package/lib/srv/protocols/index.js

@@ -50,6 +50,12 @@ class Protocols {
     const cached = srv._adapters ??= {}
     let n = 0
 
+    if (app) {
+      // disable express etag handling
+      app.disable?.('etag')
+      // app.disable('x-powered-by')
+    }
+
     for (let { kind, path } of endpoints) {
 
       // construct adapter instance from resolved implementation
@@ -99,8 +105,8 @@ class Protocols {
   /**
    * Returns the endpoints for the given instance of cds.Service.
    * Used in this.serve() and the outcome stored in srv.endpoints property.
-   * IMPORTANT: Currently only used internally in this module and should stay
-   * that way -> don't use anywhere else.
+   * IMPORTANT: Currently only used internally in this module, e.g. serviceinfo,
+   * and should stay that way -> don't use anywhere else.
    * @returns {{ kind:string, path:string }[]} Array of { kind, path } objects
    */
   endpoints4 (srv, o = srv.options) {
@@ -144,14 +150,14 @@ class Protocols {
 
   /**
    * For compatibility with old @sap/cds-dk versions <= 7.4.0
-   * @deprecated Use def._serves_odata instead
+   * @deprecated Use def.protocols instead
    */
   protocol4 (def) {
-    return def._serves_odata ? ['odata'] : []
+    return def.protocols?.odata ? ['odata'] : []
   }
 
   /**
-   * Rarely used, e.g., by compile.to.srvinfo, and by compile.to.openapi:
+   * Rarely used, e.g., by compile.to.openapi:
    * NOT PUBLIC API, hence not documented.
    */
   path4 (srv,o) {
@@ -163,14 +169,26 @@ class Protocols {
    * Internal modules may use this to determine if the service is configured to serve OData.
    * NOT PUBLIC API, hence not documented.
    */
-  _serves_odata (def) {
-    const a = def['@protocol']
-    const vals = {odata: 1, 'odata-v4': 1}
-    if (a) return typeof a === 'string' ? a in vals : a.some(p => (p.kind||p) in vals)
-    if (def['@odata']) return true
-    if (def['@rest']) return false
-    for (let p in this) if (def['@'+p] || def['@protocol.'+p]) return false
-    return this.default === 'odata'
+  for (def) {
+    const protocols={}; let any
+
+    // check @protocol annotation -> deprecated, only for 'none'
+    const anno = def['@protocol']
+
+    if (anno === 'none') return protocols
+    if (typeof anno === 'string') any = protocols [anno] = 1
+    else if (anno) for (let p of anno) any = protocols[p.kind||p] = 1
+
+    // @odata, @rest, ... annotations -> preferred
+    else for (let p in this) if (def['@'+p] || def['@protocol.'+p]) any = protocols[p] = 1
+
+    // add default protocol, if none is annotated
+    if (!any) protocols[this.default] = 1
+
+    // allow for simple 'odata' in srv.protocols checks
+    if (protocols['odata-v4']) protocols.odata = 1
+
+    return protocols
   }
 }