@sap/cds 5.4.6 → 5.5.0

package/lib/index.js

@@ -5,12 +5,7 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
 
     get version() { return super.version = require('../package.json').version }
     get env() { return super.env = require('./env') }
-    get requires() { // shortcut, with resolved indirections
-      const dict = Object.create (this.env.requires)
-      for (let e of Object.values (this.env.requires)) if (e.service)  dict[e.service] = e
-      return super.requires = dict
-    }
-
+    get requires() { return super.requires = this.env.required_services_or_defs }
     get builtin() { return super.builtin = require ('./core') }
     get service() { return super.service = extend (this.builtin.classes.service) .with ({
       /** @param x {(this:Service, srv:Service) => any} */ impl: x=>x,
@@ -68,16 +63,20 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
 
     // Core Services API
     Service: require ('./serve/Service-api'),
-    ApplicationService: lazy => require('../libx/_runtime/cds-services/services/Service.js'),
-    MessagingService: lazy => require('../libx/_runtime/messaging/service.js'),
-    DatabaseService: lazy => require('../libx/_runtime/db/Service.js'),
-    RemoteService: lazy => require('../libx/_runtime/rest/service.js'),
     Request: require ('./req/impl'),
     Event: require ('./req/event'),
     User: require ('./req/user'),
     ql: require ('./ql'),
+    spawn: lazy => cds.Event.spawn,
     /** @type Service */ db: undefined,
 
+    // Protocols and Periphery
+    ApplicationService: lazy => require('../libx/_runtime/cds-services/services/Service.js'),
+    MessagingService: lazy => require('../libx/_runtime/messaging/service.js'),
+    DatabaseService: lazy => require('../libx/_runtime/db/Service.js'),
+    RemoteService: lazy => require('../libx/_runtime/rest/service.js'),
+    odata: require('../libx/_runtime/odata'),
+
     // Helpers
     localize: require ('./i18n/localize'),
     error: require ('./log/errors'),

package/lib/lazy.js

@@ -20,8 +20,8 @@ const extend = (target) => ({
 })
 
 const _excludes = {
-  function: { name: 1, length: 2, arguments: 3, caller: 4, prototype: 5 },
-  object: { constructor: 1 },
+  function: Object.assign(Object.create(null),{ name: 1, length: 2, arguments: 3, caller: 4, prototype: 5 }),
+  object: Object.assign(Object.create(null),{ constructor: 1 }),
 }
 
 /** @type <T>(target:T) => T */

package/lib/log/index.js

@@ -10,7 +10,6 @@ if (log.Logger || log.service) {
 }
 
 
-
 /**
  * Returns a trace logger for the given module if trace is switched on for it,
  * otherwise returns null. All cds runtime packages use this method for their
@@ -21,19 +20,34 @@ if (log.Logger || log.service) {
  *
  * You can also specify alternate module names:
  *
- *    const LOG = cds.log('db|sql')
+ *    const LOG = cds.log('sql|db')
+ *
+ * By default this logger would prefix all output with '[sql] - '.
+ * You can change this by specifying another prefix in the options:
+ *
+ *    const LOG = cds.log('sql|db',{ prefix:'cds.ql' })
+ *
+ * Call cds.log() for a given module again to dynamically change the log level
+ * of all formerly created loggers, for example:
+ *
+ *    const LOG = cds.log('sql')
+ *    LOG.info ('this will show, as default level is info')
+ *    cds.log('sql','warn')
+ *    LOG.info ('this will be suppressed now')
  *
  * Tracing can be switched on/off through env variable DEBUG:
  * Set it to a comma-separated list of modules to switch on tracing.
  * Set it to 'all' or 'y' to switch on tracing for all modules.
  *
  * @param {string} [module] the module for which a logger is requested
- * @param {string|number|{ level }} [level]  the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
+ * @param {string|number|{ level, prefix }} [options] the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
  */
-module.exports = exports = function cds_log (module, level) { // NOSONAR
-  const id = module ? module.match(/^[^|]+/)[0] : 'cds'
-  const logger = cached[id]; if (logger && !level) return logger
-  if (typeof level === 'object') level = level.level
+module.exports = exports = function cds_log (module, options) { // NOSONAR
+  let id = module ? module.match(/^[^|]+/)[0] : 'cds'
+  let logger = cached[id]; if (logger && !options) return logger
+
+  let { level, prefix } = typeof options === 'object' ? options : {level:options}
+  if (!prefix) prefix = logger && logger.prefix || id
   if (!level) level = (
     process.env.DEBUG && process.env.DEBUG.match(RegExp(`\\b(y|all|${module||'any'})\\b`)) ? DEBUG :
     log.levels[id] || INFO
@@ -41,15 +55,20 @@ module.exports = exports = function cds_log (module, level) { // NOSONAR
   if (typeof level === 'string') {
     level = exports.levels [level.toUpperCase()]
   }
+
+  // IMPORTANT: cds.log() can be called again to change the log level
+  // of formerly constructed loggers!!
   if (logger && logger.level === level) return logger
-  return cached[id] = new Logger (id,level)
+  else logger = exports.Logger (prefix, level)
+  return cached[id] = Object.assign (cached[id] || logger.log, logger, {
+    id, level, prefix, setFormat(fn){ logger.format = fn }
+  })
 }
 
 
 /**
  * Shortcut to `cds.log(...).debug`, returning undefined if `cds.log(...)._debug` is false.
  * @param {string} [module] the module for which a logger is requested
- * @param {string|{ level, prefix }} [prefix] a prefix to prepend to each log output, default: '[cds.<module>] -'
  */
 exports.debug = function cds_debug (module) {
   const L = this.log (module)
@@ -70,13 +89,13 @@ exports.debug = function cds_debug (module) {
  */
 /* eslint-disable no-console */
 exports.Logger = (module, level) => {
-  const fmt = (level,args) => log.format (module,level,...args)
-  const log = Object.assign ({
+  const fmt = (level,args) => logger.format (module,level,...args)
+  const logger = Object.assign ({
     format: exports.format,
     trace:  level < TRACE ? ()=>{} : (...args) => console.trace (...fmt(TRACE,args)),
     debug:  level < DEBUG ? ()=>{} : (...args) => console.debug (...fmt(DEBUG,args)),
     log:    level < INFO  ? ()=>{} : (...args) => console.log (...fmt(INFO,args)),
-    info:   level < INFO  ? ()=>{} : (...args) => console.log (...fmt(INFO,args)),
+    info:   level < INFO  ? ()=>{} : (...args) => console.info (...fmt(INFO,args)),
     warn:   level < WARN  ? ()=>{} : (...args) => console.warn (...fmt(WARN,args)),
     error:  level < ERROR ? ()=>{} : (...args) => console.error (...fmt(ERROR,args)),
     _trace: level >= TRACE,
@@ -84,12 +103,9 @@ exports.Logger = (module, level) => {
     _info:  level >= INFO,
     _warn:  level >= WARN,
     _error: level >= ERROR,
-  }, !cds.app && { // in case of cds compile, all log output goes to stderr
-    debug:  level < DEBUG ? ()=>{} : (...args) => console.warn (...fmt(DEBUG,args)),
-    log:    level < INFO  ? ()=>{} : (...args) => console.warn (...fmt(INFO,args)),
-    info:   level < INFO  ? ()=>{} : (...args) => console.warn (...fmt(INFO,args)),
   })
-  return log
+  // deleted stdout -> stderr redirection for cds compile as bin/utils/log.js is used
+  return logger
 }
 
 
@@ -110,35 +126,7 @@ exports.format = (
 )
 
 
-/**
- * Helper fundcion to construct new Loggers, updating an already cached one
- * with new log levels, if exists.
- */
-function Logger (id,level,prefix) {
-  const logger = exports.Logger (id, level, prefix)
-  return Object.assign (cached[id] || logger.log, logger, {
-    id, level, prefix, setFormat(fn){ logger.format = fn }
-  })
-}
-
-
 const { ERROR, WARN, INFO, DEBUG, TRACE } = exports.levels = {
   SILENT:0, ERROR:1, WARN:2, INFO:3, DEBUG:4, TRACE:5, SILLY:5, VERBOSE:5
 }
 const cached = exports.loggers = {}
-
-Object.defineProperty (exports,'cache',{
-  configurable: true,
-  get(){
-    Object.defineProperty (exports,'cache',{value:cached})
-    console.trace(`
-    -----------------------------------------------------------------
-
-      WARNING: You are using inofficial and removed cds.log.cache,
-      which was already removed -> please fix this coding.
-
-    -----------------------------------------------------------------
-    `)
-    return cached
-  }
-})

package/lib/log/service/index.js

@@ -60,13 +60,13 @@ module.exports = class LogService extends cds.Service {
     this.on('debug', (req)=>{
       const [,id] = /debug\(module=([^)]+)\)/.exec(req.params[0]) || []
       if (!id) return req.reject('No logger id specified in request')
-      return _logger (cds.log (id,'debug'))
+      return _logger (cds.log (id, {level:'debug'}))
     })
 
     this.on('reset', (req)=>{
       const [,id] = /reset\(module=([^)]+)\)/.exec(req.params[0]) || []
       if (!id) return req.reject('No logger id specified in request')
-      return _logger (cds.log (id,'info'))
+      return _logger (cds.log (id, {level:'info'}))
     })
 
     this.on('format', (req)=>{

package/lib/ql/CREATE.js

@@ -1,20 +1,25 @@
 const Query = require('./Query')
 const $ = Object.assign
 
-
 module.exports = class CREATE extends Query {
-  static get _() {
-    return $((..._) => new this().entity(..._), {
-      entity: (..._) => new this().entity(..._),
+
+  static _api() {
+    return $((..._) => (new this).entity(..._), {
+      entity: (..._) => (new this).entity(..._),
     })
   }
-  entity(e, elements) {
-    this._.entity = e
-    this._.elements = elements
+
+  entity (e, elements) {
+    if (elements)
+      this.CREATE.entity = { elements: elements, kind: 'entity', name:e }
+    else
+      this.CREATE.entity = e && e.elements ? e : this._target_name4(e)
     return this
   }
-  as(query) {
-    this._.as = query
+
+  as (query) {
+    if (!query || !query.SELECT) this._expected `${{query}} to be a CQN {SELECT} object`
+    this.CREATE.as = query
     return this
   }
 }

package/lib/ql/DELETE.js

@@ -1,15 +1,15 @@
 const Whereable = require('./Whereable')
-const $ = Object.assign
 
 module.exports = class DELETE extends Whereable {
-  static get _() {
-    return $((..._) => new this().from(..._), {
-      from: (..._) => new this().from(..._),
+
+  static _api() {
+    return Object.assign ((..._) => (new this).from(..._), {
+      from: (..._) => (new this).from(..._),
     })
   }
 
   from(entity, key) {
-    this._.from = this.target(entity).name
+    this.DELETE.from = this._target_name4 (entity)
     if (key) this.byKey(key)
     return this
   }
@@ -17,4 +17,5 @@ module.exports = class DELETE extends Whereable {
   valueOf() {
     return super.valueOf('DELETE FROM')
   }
+
 }

package/lib/ql/DROP.js

@@ -1,22 +1,25 @@
 const Query = require('./Query')
-const $ = Object.assign
 
 module.exports = class DROP extends Query {
-  static get _() {
-    return $((..._) => new this().entity(..._), {
-      entity: (e) => new this().entity(e),
-      table: (e) => new this().table(e),
-      view: (e) => new this().view(e),
+  static _api() {
+    return Object.assign ((e)  => (new this).entity(e), {
+      entity: (e) => (new this).entity(e),
+      table: (e)  => (new this).table(e),
+      view: (e)   => (new this).view(e),
     })
   }
   entity(e) {
-    this._.entity = this.target(e).name
+    this.DROP.entity = this._target_name4 (e)
     return this
   }
   table(e) {
-    return this.entity((this._.table = e))
+    const {DROP} = this
+    DROP.entity = DROP.table = this._target_name4 (e)
+    return this
   }
   view(e) {
-    return this.entity((this._.view = e))
+    const {DROP} = this
+    DROP.entity = DROP.view = this._target_name4 (e)
+    return this
   }
 }

package/lib/ql/INSERT.js

@@ -1,38 +1,62 @@
 const Query = require('./Query')
 const is_array = Array.isArray
-const $ = Object.assign
 
 module.exports = class INSERT extends Query {
-  static get _() {
-    return $((..._) => new this().entries(..._), {
-      into: (..._) => new this().into(..._),
+  static _api() {
+    return Object.assign ((..._) => (new this).entries(..._), {
+      into: (..._) => (new this).into(..._),
     })
   }
 
-  into(entity, ...data) {
-    this._.into = this.target(entity).name
+  into (entity, ...data) {
+    this.INSERT.into = this._target_name4 (entity)
     if (data.length) this.entries(...data)
     return this
   }
 
-  entries(...x) {
-    this._.entries = is_array(x[0]) ? x[0] : x
+  entries (...x) {
+    this.INSERT.entries = is_array(x[0]) ? x[0] : x
     return this
   }
-  columns(...x) {
-    this._.columns = is_array(x[0]) ? x[0] : x
+  columns (...x) {
+    this.INSERT.columns = is_array(x[0]) ? x[0] : x
     return this
   }
-  values(...x) {
-    this._.values = is_array(x[0]) ? x[0] : x
+  values (...x) {
+    this.INSERT.values = is_array(x[0]) ? x[0] : x
     return this
   }
-  rows(...x) {
-    this._.rows = is_array(x[0]) && is_array(x[0][0]) ? x[0] : x
+  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.INSERT.rows = rows
     return this
   }
-  as(query) {
-    this._.as = query
+  _rows(rows, ...args) {
+
+    if (Array.isArray(rows)) {
+      // check if all the entries in the array are arrays
+      if (rows.every(e => Array.isArray(e))) {
+        this.INSERT.rows = rows
+        // check if array contains one or multiple objects
+      } else if (rows.every(e => typeof e === 'object')) {
+        this.INSERT.entries = rows
+        // the rows have been added as arguments
+      } else if (args.length !== 0) {
+        args.unshift(rows)
+        this.INSERT.rows = args
+      } else {
+        this.INSERT.values = rows
+      }
+    } else if (typeof rows === 'object') {
+      this.INSERT.entries = rows
+    }
+
+    return this
+  }
+  as (query) {
+    if (!query || !query.SELECT) this._expected `${{query}} to be a CQN {SELECT} query object`
+    this.INSERT.as = query
     return this
   }
   valueOf() {

package/lib/ql/Query.js

@@ -1,59 +1,86 @@
-const set = (o,p,v) => Object.defineProperty (o,p, { value:v, configurable:true })
-const { inspect } = module.require('util')
-const {cds} = global
+const { inspect } = require('util')
+const cds = require('../index')
 
 module.exports = class Query {
 
-  constructor(_={}) {
-    const cmd = this.constructor.name
-    set (this, '_', this[cmd] = _)
-    set (this, 'cmd', cmd)
-  }
+  constructor(_={}) { this[this.cmd] = _ }
 
-  target(e) {
-    return set (this,'_target', e.name ? e : e._target || { name: e })._target
+  /** Creates a derived instance that initially inherits all properties. */
+  clone(){
+    return { __proto__:this, [this.cmd]: {__proto__: this[this.cmd]} }
   }
 
-  bind(srv) {
-    return set (this,'_srv',srv)
+  /** Binds this query to be executed with the given service */
+  bind (srv) {
+    return Object.defineProperty (this,'_srv',{value:srv})
   }
 
   /** Turns all queries into Thenables which execute with primary db by default */
-  then(r,e) {
-    let {_promised} = this; if (!_promised) {
-      const srv = this._srv || this._target._service && cds.services[this._target._service.name] || cds.db
-      set (this,'_promised', _promised = srv.run(this))
-    }
-    return _promised.then(r,e)
+  then (r,e) {
+    return (this._srv || cds.db) .run (this) .then (r,e)
   }
 
-  async foreach(cb) {
-    return (await this).map(cb)
+  /** Beautifies output in REPL */
+  [inspect.custom]() {
+    const {cmd} = this, colors = process.env.CDS_TERM_COLORS !== false
+    return `{ ${cmd}: `+ inspect(this[cmd], { colors, depth: 22 })
+      .replace(/^\w*\s/, '')
+      .replace(
+        /{ ref: \[([^\]]*)\] }/g,
+        (_,ref) => '{ref:[' + ref.slice(1, -1) + ']}'
+      )
+      .replace(/{ val: ([^ ]*) }/g, '{val:$1}')
+      .replace(/{ (xpr|ref|val): /g, '{$1:') +
+    '}'
   }
 
-  clone() {
-    return new this.constructor({ ...this._ })
+  _target_ref4 (target) {
+
+    // Resolving this._target --> REVISIT: this is not reliable !!!
+    Object.defineProperty (this, '_target', { value: target && (
+      typeof target === 'string' ? { name: target } :
+      target.name ? target : //> assumed to be a linked csn definition
+      target.ref ? { name: target.ref[0] } :
+      target._target || { name: undefined }
+    ), configurable:true })
+
+    return target && (
+      typeof target === 'string' ? cds.parse.path(target) :
+      target.ref    ? target :
+      target.SELECT ? target :
+      target.SET    ? target :
+      target.raw    ? cds.parse.path(...arguments) :
+      target.name   ? {ref:[target.name]} : 0
+    )
+    || this._expected `${{target}} to be an entity path string, a CSN definition, a {ref}, a {SELECT}, or a {SET}`
   }
 
-  valueOf (qo='Query on') {
-    return qo + ' ' + this._target.name.replace(/[.:]/g, '_') + ' '
+  //> REVISIT: should we rather have consistent .from/.entity/.into in CQN?
+  _target_name4 (target) {
+    const {ref} = this._target_ref4 (target)
+    return ref.length === 1 && typeof ref[0] === 'string' ? ref[0] : {ref}
   }
 
-  // beautify output in REPL
-  [inspect.custom]() {
-    const colors = process.env.CDS_TERM_COLORS !== false
-    const cmd = this.cmd
-    return (
-      `{ ${cmd}: ` +
-      inspect(this[cmd], { colors, depth: 22 })
-        .replace(/^\w*\s/, '')
-        .replace(
-          /{ ref: \[([^\]]*)\] }/g,
-          (_, ref) => '{ref:[' + ref.slice(1, -1) + ']}'
-        )
-        .replace(/{ val: ([^ ]*) }/g, '{val:$1}')
-        .replace(/{ (xpr|ref|val): /g, '{$1:') +
-      '}'
-    )
+  _expected (...args) {
+    return cds.error.expected (...args)
+  }
+
+  _own (property, _ = this[this.cmd]) {
+    const pd = Reflect.getOwnPropertyDescriptor (_, property)
+    return pd && pd.value
+  }
+
+  _add (property, values) {
+    const _ = this[this.cmd], pd = Reflect.getOwnPropertyDescriptor (_,property)
+    _[property] = !pd || !pd.value ? values : [ ...pd.value, ...values ]
+    return this
+  }
+
+  valueOf (cmd=this.cmd) {
+    return `${cmd} ${_name(this._target.name)} `
   }
+
 }
+
+
+const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')