@sap/cds 8.9.3 → 9.0.2

package/lib/plugins.js

@@ -1,27 +1,28 @@
+const DEBUG = /plugins/.test(process.env.DEBUG) ? console : undefined // eslint-disable-line no-console
 const cds = require('.')
 const prio_plugins = {
-  '@cap-js/telemetry': true // to allow better instrumentation.
+  '@sap/cds-mtxs': true,    // plugins may register handlers for mtxs services
+  '@cap-js/telemetry': true // to allow better instrumentation
 }
 
-exports.require = require
-
 /**
  * Fetch cds-plugins from project's package dependencies.
  * Used in and made available through cds.env.plugins.
  */
 exports.fetch = function (DEV = process.env.NODE_ENV !== 'production') {
+  DEBUG?.time ('[cds.plugins] - fetched plugins in')
   const plugins = {}
   fetch_plugins_in (cds.home, false)
   fetch_plugins_in (cds.root, DEV)
   function fetch_plugins_in (root, dev) {
-    let pkg; try { pkg = exports.require(root + '/package.json') } catch { return }
+    let pkg; try { pkg = require(root + '/package.json') } catch { return }
     let deps = { ...pkg.dependencies, ...dev && pkg.devDependencies }
     for (let each in deps) try {
-      let impl = exports.require.resolve(each + '/cds-plugin', { paths: [root] })
-      const packageJson = exports.require.resolve(each + '/package.json', { paths: [root] })
-      plugins[each] = { impl, packageJson }
+      let impl = require.resolve(each + '/cds-plugin', { paths: [root] })
+      plugins[each] = { impl }
     } catch { /* no cds-plugin.js */ }
   }
+  DEBUG?.timeEnd ('[cds.plugins] - fetched plugins in')
   return plugins
 }
 
@@ -30,11 +31,10 @@ exports.fetch = function (DEV = process.env.NODE_ENV !== 'production') {
  * Used in and made available through cds.plugins.
  */
 exports.activate = async function () {
-  const DEBUG = cds.debug ('plugins', {label:'cds'})
-  DEBUG?.time ('[cds] - loaded plugins in')
+  DEBUG?.time ('[cds.plugins] - loaded plugins in')
   const { plugins } = cds.env, { local } = cds.utils
   const loadPlugin = async ([plugin, conf]) => {
-    DEBUG?.(`loading plugin ${plugin}:`, { impl: local(conf.impl) })
+    DEBUG?.log(`[cds.plugins] - loading ${plugin}:`, { impl: local(conf.impl) })
     const p = cds.utils._import (conf.impl)
     if (p.activate) {
       cds.log('plugins').warn(`WARNING: \n
@@ -48,6 +48,6 @@ exports.activate = async function () {
   const all = Object.entries(plugins)
   await Promise.all (all .filter(([name]) =>  prio_plugins[name]) .map (loadPlugin))
   await Promise.all (all .filter(([name]) => !prio_plugins[name]) .map (loadPlugin))
-  DEBUG?.timeEnd ('[cds] - loaded plugins in')
+  DEBUG?.timeEnd ('[cds.plugins] - loaded plugins in')
   return plugins
 }

package/lib/ql/CREATE.js

@@ -23,7 +23,7 @@ class CREATE extends Query {
     return this
   }
 
-  get _target_ref(){ return this.CREATE.entity }
+  get _subject(){ return this.CREATE.entity }
 }
 
 /** @type CREATE.API & (...entries:[]) => CREATE */

package/lib/ql/DELETE.js

@@ -19,7 +19,7 @@ class DELETE extends Whereable {
     return super.valueOf('DELETE FROM')
   }
 
-  get _target_ref(){ return this.DELETE.from }
+  get _subject(){ return this.DELETE.from }
 }
 
 /** @type DELETE.API & (...entries:[]) => DELETE */

package/lib/ql/DROP.js

@@ -26,7 +26,7 @@ class DROP extends Query {
     return this
   }
 
-  get _target_ref(){ return this.DROP.entity }
+  get _subject(){ return this.DROP.entity }
 }
 
 /** @type DROP.API & (...entries:[]) => DROP */

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