@sap/cds 8.9.4 → 9.0.2

package/lib/ql/INSERT.js

@@ -10,7 +10,7 @@ class INSERT extends Query {
   }
 
   into (entity, ...data) {
-    this._.into = this._target4 (entity, ...data) // supporting tts
+    this[this.kind].into = this._target4 (entity, ...data) // supporting tts
     if (data.length) this.entries(...data)
     return this
   }
@@ -18,49 +18,40 @@ class INSERT extends Query {
   entries (...x) {
     if (!x.length) return this
     if (x[0].SELECT) return this.from(x[0])
-    this._.entries = is_array(x[0]) ? x[0] : x
+    this[this.kind].entries = is_array(x[0]) ? x[0] : x
     return this
   }
   columns (...x) {
-    this._.columns = is_array(x[0]) ? x[0] : x
+    this[this.kind].columns = is_array(x[0]) ? x[0] : x
     return this
   }
   values (...x) {
-    this._.values = is_array(x[0]) ? x[0] : x
+    this[this.kind].values = is_array(x[0]) ? x[0] : x
     return this
   }
   rows (...rows) {
     if (is_array(rows[0]) && is_array(rows[0][0])) rows = rows[0]
     if (!is_array(rows[0])) this._expected `Arguments ${{rows}} to be an array of arrays`
-    this._.rows = rows
+    this[this.kind].rows = rows
     return this
   }
 
   from (query) {
     if (!query) return this
-    if (!query.SELECT) {
-      if (query.name || typeof query === 'string') query = SELECT.from(query)
-      else this._expected `${{query}} to be a CQN {SELECT} query object`
-    }
-    this._.as = query // REVISIT: should we also change CSN spec, and adopt db service impls?
+    else if (query.name || typeof query === 'string') query = SELECT.from(query)
+    else if (!query.SELECT) this._expected `${{query}} to be a CQN {SELECT} query object`
+    this[this.kind].from = query
     return this
   }
 
-  /** @deprecated */ as(q) { return this.from(q) }
-
   valueOf() {
     return super.valueOf('INSERT INTO')
   }
 
-  get _target_ref(){ return ( this.INSERT || this.UPSERT ).into }
+  get _subject(){ return this.INSERT.into }
 }
 
 const is_array = Array.isArray
 
-INSERT.prototype.as = require('../utils').deprecated (INSERT.prototype.as, {
-  old:'INSERT.as(SELECT)',
-  use:'INSERT.entries(SELECT)'
-})
-
 /** @type INSERT.API & (...entries:[]) => INSERT */
 module.exports = INSERT.init()

package/lib/ql/SELECT.js

@@ -70,10 +70,11 @@ class SELECT extends Whereable {
 
   /** @private */ _ambiguous (...xy) {
     const {SELECT:_} = this, {one} = _
-    return this.from(...xy)._set('from', (...the_real_target) => {
+    this.from(...xy)._set('from', (...the_real_target) => {
       if (!one) delete _.one; delete _.columns; delete this.from
       return this.from (...the_real_target) .columns (...xy)
     })
+    return this
   }
 
   columns (...cols) {
@@ -102,17 +103,17 @@ class SELECT extends Whereable {
     return this
   }
 
-  fullJoin  (other, as) { return this.join (other, as, 'full') }
-  leftJoin  (other, as) { return this.join (other, as, 'left') }
-  rightJoin (other, as) { return this.join (other, as, 'right') }
-  innerJoin (other, as) { return this.join (other, as, 'inner') }
-  join (other, as, kind='inner') {
+  /** @deprecated */ fullJoin  (other, as) { return this.join (other, as, 'full') }
+  /** @deprecated */ leftJoin  (other, as) { return this.join (other, as, 'left') }
+  /** @deprecated */ rightJoin (other, as) { return this.join (other, as, 'right') }
+  /** @deprecated */ innerJoin (other, as) { return this.join (other, as, 'inner') }
+  /** @deprecated */ join (other, as, kind='inner') {
     const [, target, alias = as] = /(\S+)(?:\s+(?:as)?\s+(\S+))?/i.exec(other)
     const ref = { ref: [target] }; if (alias) ref.as = alias
     this.SELECT.from = { join:kind, args: [this.SELECT.from, ref] }
     return Object.defineProperty(this, '_where_or_having', { value: 'on', configurable: true })
   }
-  on (...args) {
+  /** @deprecated */ on (...args) {
     const {from} = this.SELECT
     if (!from?.join) throw new Error(`Invalid call of "SELECT.on()" without prior call of "SELECT.join()"`)
     // string values in on clause are interpreted as refs, not vals
@@ -157,27 +158,19 @@ class SELECT extends Whereable {
     return this
   }
 
-  forShareLock () {
+  /** @deprecated */ forShareLock () {
     this.SELECT.forShareLock = true
     return this
   }
 
-  foreach (callback) {
-    return this.then(rows => rows.map(callback))
-  }
-
-  valueOf () {
-    return super.valueOf('SELECT * FROM')
-  }
-
   hints (...args) {
     if (args.length) this.SELECT.hints = args.flat()
     return this
   }
 
-  /** @private */ get _target_ref(){ return this.SELECT.from }
-
-  get elements() { return this.elements = cds.infer.elements4 (this.SELECT.columns, this.source) }
+  valueOf() { return super.valueOf('SELECT * FROM') }
+  get _subject(){ return this.SELECT.from }
+  get elements() { return this.elements = cds.infer.elements (this) }
   set elements(e) { this._set('elements',e) }
 }
 

package/lib/ql/UPDATE.js

@@ -65,7 +65,7 @@ class UPDATE extends Whereable {
     return this
   }
 
-  get _target_ref(){ return this.UPDATE.entity }
+  get _subject(){ return this.UPDATE.entity }
 }
 
 

package/lib/ql/UPSERT.js

@@ -10,6 +10,7 @@ class UPSERT extends INSERT {
     into: (..._) => (new this).into(..._)
   }
 
+  get _subject(){ return this.UPSERT.into }
 }
 
 /** @type UPSERT.API & (...entries:[]) => UPSERT */

package/lib/ql/Whereable.js

@@ -9,7 +9,7 @@ class Whereable extends Query {
   or (...args) { return this._and_or ('or',args) }
 
   /** @protected */
-  _where (args, clause='where', cqn=this._) {
+  _where (args, clause='where', cqn=this[this.kind]) {
     let tail = cds.ql.predicate(...args); if (!tail?.length) return this
     let head = cqn[clause]
     if (!head) cqn[clause] = tail
@@ -24,14 +24,15 @@ class Whereable extends Query {
 
   /** @private */
   _and_or (ao, args) {
+    const $ = this[this.kind]
     let clause = this._clause ??= ( //> some projects use .and()/.or() with manually filled in .where
-      this._.having ? 'having' :
-      this._.where ? 'where' :
-      this._.from?.on ? 'on' :
+      $.having ? 'having' :
+      $.where ? 'where' :
+      $.from?.on ? 'on' :
       cds.error `Unexpected use of .${ao}() without prior .where(), .having(), or .on()`
     )
     let tail = cds.ql.predicate(...args); if (!tail?.length) return this
-    let cqn = clause === 'on' ? this._.from : this._
+    let cqn = clause === 'on' ? $.from : $
     let head = cqn[clause], direct = this._direct; delete this._direct
     if (direct && ao === 'and') //> wrap ORs for .and() directly following .where()
       if (head.includes('or')) head = [{xpr:head}]
@@ -45,7 +46,7 @@ class Whereable extends Query {
       key = cds.env.features.keys_as_val ? { val: 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)
-    const {ref} = this._target_ref
+    const {ref} = this._subject
     ref[ref.length-1] = { id: ref.at(-1), where: cds.ql.predicate(key) }
     return this
   }

package/lib/ql/cds-ql.js

@@ -229,15 +229,3 @@ const is_array = Array.isArray
 exports.clone = function (q,_) {
   return Query.prototype.clone.call(q,_)
 }
-
-/**
- * For questionable tests only.
- * @protected @deprecated
- */
-exports._reset = ()=>{
-  const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
-  Object.defineProperty (Query.prototype,'valueOf',{ configurable:1, value: function(kind=this.kind) {
-    return `${kind} ${_name(this._target.name)} `
-  }})
-  return this
-}

package/lib/ql/cds.ql-Query.js

@@ -1,14 +1,11 @@
 const { AsyncResource } = require('async_hooks')
 const cds = require('../index')
-
-const cloned = from => from.ref ? { ...from, ref:[...from.ref] } : { ...from }
 const cached = {}
 
 
 class Query {
 
-  /** @private */
-  static init () {
+  static init() {
     const self = this, kind = self.name
     Object.defineProperty (this.prototype, 'kind', {value:kind})
     Object.defineProperty (this, 'name', {value:'cds.ql'})
@@ -22,9 +19,6 @@ class Query {
   /** @private to be implemented in subclassed*/
   static call() {}
 
-  /** @private */
-  get _(){ return this[this.kind] }
-
 
   /**
    * The kind of query, as in CQN's SELECT, INSERT, UPDATE, DELETE, CREATE, DROP.
@@ -37,7 +31,7 @@ class Query {
    * sub selects in columns, which in turn may has aliases in .as.
    */
   alias (a) {
-    this._target_ref.as = a
+    this._subject.as = a
     return this
   }
 
@@ -57,7 +51,6 @@ class Query {
 
   /** Binds this query to be executed with the given service */
   bind (srv) {
-    // TODO: resolve target from srv.entities -> but better do that in .from
     return Object.defineProperty (this,'_srv',{ value:srv, configurable:true, writable:true })
   }
 
@@ -68,83 +61,50 @@ class Query {
     return (r,e) => q.runInAsyncScope (srv.run, srv, this).then (r,e)
   }
 
-  /** @private */ get _target_ref() { return this._.from } // overridden in subclasses
-  /** @private */ set _target(t) { this._set('_target', t.ref ? {name:t.ref[0]} : t) }
-
-  /**
-   * @param {string | Function | object} t - the target
-   * @param {unknown[]} etc - additional arguments
-   * @returns {typeof this._target | import('@sap/cds').ref}
-   * @private
-  **/
-  _target4 (t,...etc) {
-    switch (typeof t) {
-      case 'string': {
-        // NOTE: even though this._target will be {name:ref[0]} this returns the parsed {ref}
-        // NOTE: we need to clone cached refs, as they might get modified afterwards
-        return this._target = cloned (cached[t] ??= cds.parse.path(t))
-      }
-      case 'function':  // fallthrough for classes generated by cds-typer. Will end up in t.name subcase
-      case 'object': {
-        if (t.raw) return this._target = !etc.length ? this._target4(t[0]) : cds.parse.path(t,...etc)
-        if (t.name) return {ref:[ (this._target = t).name ]}
-        if (t.ref || t.SELECT || t.SET) return this._target = t
-      }
+  get _subject() { throw new Error('should be overridden in subclasses') }
+  set _target(t) { this._set('_target',t) } // ensure non-enumerable
+
+  /** @returns {ref:string[]} */
+  _target4 (x,...y) {
+    if (typeof x === 'string') {
+      const r = cached[x] ??= cds.parse.path(x); this._target = {name:r.ref[0]}
+      return { ...r, ref:[...r.ref] } // clone ref, as they may get modified
+    } else if (x) {
+      if (x.raw)    return this._target4 (y.length ? cds.parse.path(x,...y) : x[0])
+      if (x.ref)    return this._target = {name:x.ref[0]}, x
+      if (x.name)   return this._target = x, {ref:[x.name]}
+      if (x.SELECT) return this._target = x
+      if (x.SET)    return this._target = x
     }
-    throw this._expected `${{target:t}} to be an entity path string, a CSN definition, a {ref}, a {SELECT}, a {SET}, or a class representing an entity definition`
+    throw this._expected `${{target:x}} to be a CSN entity, an entity name or path, a {ref}, or a subquery`
   }
 
-  /** @private */ _expected (...args) {
+  _expected (...args) {
     return cds.error.expected (...args)
   }
 
-  /** @private */ _assign (...aspects) {
-    Object.assign (this._, ...aspects)
+  _assign (...aspects) {
+    Object.assign (this[this.kind], ...aspects)
     return this
   }
 
-  /** @private */ _add (property, values) {
-    const {_} = this, pd = Reflect.getOwnPropertyDescriptor (_,property)
-    _[property] = !pd?.value ? values : [ ...pd.value, ...values ]
+  _add (property, values) {
+    const $ = this[this.kind], pd = Reflect.getOwnPropertyDescriptor ($,property)
+    $[property] = !pd?.value ? values : [ ...pd.value, ...values ]
     return this
   }
 
-  /** @private */ _set (property, value) {
-    return Object.defineProperty (this, property, { value, configurable:true, writable:true })
+  _set (property, value) {
+    Object.defineProperty (this, property, { value, configurable:true, writable:true })
+    return value
   }
 
   valueOf (prelude = this.kind) {
     return `${prelude} ${_name(this._target.name)} `
   }
-
-  /**
-   * Returns the inferred query's source, which is the entity referred
-   * to in SELECT.from, INSERT.into, UPDATE.entity, or DELETE.from,
-   * or a sub query specified in SELECT.from, INSERT.into,
-   */
-  get source() {
-    const m = this._srv?.model || cds.context?.model || cds.model
-    return cds.infer (this, m?.definitions, 'get source')
-  }
-  set source(t) { this._set('source',t) }
-
-  /**
-   * Returns the inferred query's target, which is the entity referred
-   * to in SELECT.from, INSERT.into, UPDATE.entity, or DELETE.from.
-   * In case of a sub query specified in SELECT.from, INSERT.into,
-   * returns the target of the sub query, recursively.
-   */
-  get target() {
-    if (this._target instanceof cds.entity) return super.target = this._target
-    const m = this._srv?.model || cds.context?.model || cds.model
-    return this.target = cds.infer (this, m?.definitions)
-  }
-  set target(t) { this._set('target',t) }
-
-  /** @deprecated use .kind instead */
-  get cmd() { return this.kind }
 }
 
 const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
-
+const _no_target = ()=>{ throw cds.error `Queries don't have a 'target' property. Use 'req.target' instead.` }
+Object.defineProperty (Query.prototype, 'target', { get:_no_target, set:_no_target })
 module.exports = Query

package/lib/ql/cds.ql-infer.js

@@ -1,127 +1,116 @@
 const cds = require('../index')
+const infer = exports = module.exports = (..._) => infer.target(..._)
+
 
 /**
  * Infers the target entity of a query
+ * @param {import('./cds.ql-Query')} q
  */
-function infer (q, defs, _get_source) {
-  if (q._target instanceof cds.entity) return q._target
-  let from = q._target_ref
-    || q.SELECT?.from
-    || q.INSERT?.into
-    || q.UPSERT?.into
-    || q.UPDATE?.entity
-    || q.DELETE?.from
-  let source = infer_from (from, defs)
-  let target = source?.SELECT ? infer(source, defs) : source
-
-  Object.defineProperties (q, {
-    _target: { value: target, configurable:true, writable:true },
-    target: { value: target, configurable:true, writable:true },
-    source: { value: source, configurable:true, writable:true },
-  })
-  return _get_source ? source : target
-
-  function infer_from (from, defs={}) {
-    if (!from) return undefined
-    if (from.ref) return infer_ref (from.ref, defs) || _unresolved(from.ref[0])
-    if (from.SELECT) return from
-    if (from.SET || from.args) return undefined //> UNIONs and JOINs are not supported
-    return defs[from] || _unresolved(from) //> from is a string in quirks mode
-  }
+infer.target = function (q, ctx) {
+  if (q._target instanceof cds.entity) return q._target //> already inferred
+  const subject = _subject4(q)
+  const target = (
+    subject?.SELECT ? infer.target (subject, ctx ??= _context4(q)) :
+    subject?.ref ? infer.ref (subject.ref, ctx ??= _context4(q)) :
+    undefined
+  )
+  Object.defineProperty (q, '_target', { value: target, configurable:true, writable:true })
+  return target
+}
 
-  function infer_ref (ref, defs) {
-    let target = {elements:defs}
-    for (let r of ref) {
-      const e = target.elements?.[r.id||r]; if (!e) return
-      target = (
-        e._target ||       //> for already linked associations
-        defs[e.target] ||  //> for not yet linked associations
-        e                  //> for structs
-      )
-    }
-    return target
+infer.ref = function (ref, ctx) {
+  const defs = (ctx.model||ctx).definitions
+  let name = _name4(ref[0]), d = defs?.[name] || ctx.entities?.[name]
+  if (!d) return { name, _unresolved:true, __proto__: cds.entity.prototype }
+  else for (let i=1; i < ref.length; ++i) {
+    d = d.elements?.[name = _name4(ref[i])] || cds.error `Element ${name} not found in ${d}`
+    if (d.target) d = defs[d.target] || cds.error `Target ${d.target} not found in ${defs}`
   }
+  return d
+}
 
-  function _unresolved (x) {
-    return { name: x.id || x, __proto__: cds.entity.prototype, _unresolved:true }
+/** @param {import('./SELECT').class} q */
+infer.elements = function (q) {
+
+  const subject = _subject4(q); if (!subject) return
+  const source = subject.SELECT ? subject : infer.target(q)
+
+  return _infer_elements4 (q.SELECT.columns, source, q.SELECT.from.as)
+  function _infer_elements4 (columns, source, alias) {
+
+    // SELECT from Books; SELECT * from Books
+    if (!columns || columns.length === 1 && columns[0] === '*') return source?.elements
+
+    const elements = {}; columns.forEach (c => {
+
+      // 1) SELECT *, ... from Books
+      if (c === '*') {
+        return Object.assign (elements, source.elements)
+      }
+
+      const ref = c.ref?.map(_name4); if (alias && alias === ref?.[0] && ref.length > 1) ref.shift()
+      const as = c.as || ref?.join('_') || c.func || c.val || cds.error `Alias required for column expressions ${c}`
+      let d = source, is2many
+
+      // 2) SELECT ... : String from Books
+      if (c.cast) {
+        return elements[as] = builtin [c.cast.type]
+      }
+
+      // 3) SELECT title, author.name from Books
+      if (c.ref && d?.elements) {
+        for (let r of ref) d = (d.SELECT ? d : d._target||d).elements?.[r]
+          || cds.error `Couldn't resolve element "${ref.join('/')}" in ${source.kind} ${source.name||''} ${Object.keys(source.elements)}`
+        if (d._target) { is2many = d.is2many; c.expand || c.inline ? d = d._target : d }
+        // ... d is further processed in steps 5,6,7 below
+      }
+
+      // 4) SELECT 1, 2+3, count(*) from Books; SELECT type, name from sqlite.schema
+      else if (!c.expand) {
+        return elements[as] = _typeof(c) // { ..._typeof(c), name: as }
+      }
+
+      // 5) SELECT author.books { title } from Books
+      if (c.expand) {
+        if (d.items) { d = d.items; is2many = true }
+        d = new cds.struct ({ elements: _infer_elements4 (c.expand, d) }) //> { a, b, c } as x
+        return elements[as] = is2many ? new cds.array ({ items: d }) : d
+      }
+
+      // 6) SELECT author.books.{ title } from Books
+      if (c.inline) {
+        const nested = _infer_elements4 (c.inline, d)
+        for (let n in nested) elements[as+'_'+n] = nested[n]
+      }
+
+      // 7) SELECT title, author.name from Books
+      else return elements[as] = d // NOTE: the else is neccessary after step 5 above
+    })
+    return elements
   }
 }
 
-
-/**
- * Infers the elements according to a query's columns.
- * @param {Array} columns - the query's columns, or a nested .expand or .inline columns
- * @param {Object} source - the query's source entity or sub select
- */
-function elements4 (columns, source) {
-
-  // SELECT from Books; SELECT * from Books
-  if (!columns || columns.length === 1 && columns[0] === '*') return source?.elements
-
-  const elements = {}; columns.forEach (c => {
-
-    // 1) SELECT *, ... from Books
-    if (c === '*') {
-      return Object.assign (elements, source.elements)
-    }
-
-    const ref = c.ref?.map(r => r.id??r)
-    const as = c.as || ref?.join('_') || c.func || c.val || cds.error `Alias required for column expressions ${c}`
-    let d = source, is2many
-
-    // 2) SELECT ... : String from Books
-    if (c.cast) {
-      return elements[as] = builtin [c.cast.type]
-    }
-
-    // 3) SELECT title, author.name from Books
-    if (c.ref && d?.elements) {
-      for (let r of ref) d = (d.SELECT ? d : d._target||d).elements?.[r]
-        || cds.error `Couldn't resolve element "${ref.join('/')}" in ${source.kind} ${source.name||''} ${Object.keys(source.elements)}`
-      if (d._target) { is2many = d.is2many; c.expand || c.inline ? d = d._target : d }
-      // ... d is further processed in steps 5,6,7 below
-    }
-
-    // 4) SELECT 1, 2+3, count(*) from Books; SELECT type, name from sqlite.schema
-    else if (!c.expand) {
-      return elements[as] = _typeof(c) // { ..._typeof(c), name: as }
-    }
-
-    // 5) SELECT author.books { title } from Books
-    if (c.expand) {
-      if (d.items) { d = d.items; is2many = true }
-      d = new cds.struct ({ elements: elements4 (c.expand, d) }) //> { a, b, c } as x
-      return elements[as] = is2many ? new cds.array ({ items: d }) : d
-    }
-
-    // 6) SELECT author.books.{ title } from Books
-    if (c.inline) {
-      const nested = elements4 (c.inline, d)
-      for (let n in nested) elements[as+'_'+n] = nested[n]
-    }
-
-    // 7) SELECT title, author.name from Books
-    else return elements[as] = d // NOTE: the else is neccessary after step 5 above
-  })
-  return elements
-
-  function _typeof (c) {
-    if (c.val !== undefined) return builtin [typeof c.val] || builtin [ Number.isInteger(c.val) ? 'Integer' : 'Decimal' ]
-    if (c.func === 'count') return builtin.Integer
-    if (c.xpr?.length === 1) return _typeof(c.xpr[0])
-    return unknown
-  }
+const _context4 = q => q._srv ?? cds.context?.model ?? cds.model ?? {}
+const _subject4 = (q) => q._subject
+  || q.SELECT?.from
+  || q.INSERT?.into
+  || q.UPSERT?.into
+  || q.UPDATE?.entity
+  || q.DELETE?.from
+
+const _name4 = r => r.id || r
+const _typeof = c => {
+  if (c.val !== undefined) return builtin [typeof c.val] || builtin [ Number.isInteger(c.val) ? 'Integer' : 'Decimal' ]
+  if (c.func === 'count') return builtin.Integer
+  if (c.xpr?.length === 1) return _typeof(c.xpr[0])
+  return unknown
 }
 
-const unknown = Object.freeze (new cds.type ({ _unresolved:true }))
-const builtin = function _init (){
+const unknown = exports.unknown = Object.freeze (new cds.type ({ _unresolved:true }))
+const builtin = function() {
   const bi={}, bt = cds.builtin.types
   for (let t of Object.keys(bt)) bi[t] = bi[t.slice(4)] = { type:t, __proto__: bt[t] }
   bi.boolean = bi['cds.Boolean']
   bi.string = bi['cds.String']
   return bi
 }()
-
-module.exports = exports = Object.assign (infer, {
-  elements4, unknown
-})

package/lib/ql/resolve.js

@@ -32,11 +32,9 @@ resolve.table = target => {
 
 // REVISIT: Remove argument `skipForbiddenViewCheck` once we get rid of composition tree
 resolve.transitions = (query, tx, abortCondition, skipForbiddenViewCheck) => {
-  const target = query?.target || query?._target
-
+  const target = query && typeof query === 'object' ? cds.infer.target(query) || query?._target : undefined
   const abort = abortCondition ?? (typeof tx === 'function' ? tx : undefined)
   const _tx = typeof tx === 'function' ? cds.context?.tx : tx
-
   return getTransition(target, _tx, skipForbiddenViewCheck, undefined, {
     abort: abort ?? (tx.isDatabaseService ? _abortDB : _defaultAbort(tx))
   })

package/lib/req/context.js

@@ -1,6 +1,6 @@
 const cds = require ('../index'), { uuid } = cds.utils
 const async_events = { succeeded:1, failed:1, done:1, commit:1 }
-const req_locale = require('./locale')
+const locale = require('./../i18n/locale')
 const { EventEmitter } = require('events')
 
 /**
@@ -31,6 +31,7 @@ class EventContext {
     Object.assign (this, _)
   }
 
+  /** @type <T>( property: string, value: T ) => T */
   _set (property, value) {
     Object.defineProperty (this, property, { value, writable:true })
     return value
@@ -99,10 +100,10 @@ class EventContext {
     if (l) super.locale = super._locale = l
   }
   get locale() {
-    return super.locale = this._propagated.locale || req_locale.from(this._.req)
+    return super.locale = this._propagated.locale || locale.from(this._.req) //||this.http?.req)
   }
   get _locale() {
-    return super._locale = this._propagated._locale || req_locale.raw(this._.req)
+    return super._locale = this._propagated._locale || locale.header(this._.req) //||this.http?.req)
     || this.hasOwnProperty('locale') && this.locale // eslint-disable-line no-prototype-builtins
   }
 
@@ -117,7 +118,7 @@ class EventContext {
   }
 
   get model() {
-    const m = this._propagated.model || this.http?.req.__model // IMPORTANT: Never use that anywhere else
+    const m = this._propagated.model
     return this._set('model',m)
   }
   set model(m) {