@sap/cds 8.5.0 → 8.6.0

package/CHANGELOG.md

@@ -1,8 +1,59 @@
 # Change Log
 
 - All notable changes to this project are documented in this file.
-- The format is based on [Keep a Changelog](http://keepachangelog.com/).
-- This project adheres to [Semantic Versioning](http://semver.org/).
+- The format is based on [Keep a Changelog](https://keepachangelog.com/).
+- This project adheres to [Semantic Versioning](https://semver.org/).
+
+## Version 8.6.0 - 2024-12-17
+
+### Added
+
+- `SELECT.from` now supports full-query tagged template literals, e.g.: ``` SELECT.from`Books where ID=${201}` ```
+- `cds.ql` enhanced by functions to facilitate construction of CQN objects.
+- `cds.ql` became a function to turn CQN objects, CQL strings, or tagged template literals into instances of the respective `cds.ql` class.
+- New `cds` events to allow multitenant plugins: `compile.for.runtime`, `compile.to.dbx`, `compile.to.edmx`.
+- `cds.env` now supports `.cdsrc.js` and `.cdsrc.yaml` files, also in plugins.
+- `cds.env` now supports profile-specific `.env` files, e.g. `.hybrid.env` or `.attic.env`.
+- Experimental OData parsing for hierarchy requests (`descendants`, `ancestors`, `TopLevels`)
+- The new OData adapter now supports `cds.odata.containment`. Contained entities can only be accessed via their parents and do not show up as EntitySets in $metadata and the service document.
+
+### Changed
+
+- `CDL`, `CQL`, and `CXL` globals are deprecated => use respective functions from `cds.ql` instead.
+- `CREATE`, and `DROP` globals are deprecated => use respective functions from `cds.ql` instead.
+- Zulu time zone information is stripped from `cds.DateTime` properties when querying Odata V2 remote services
+- Processing of `@restrict.where` was aligned with CAP Java:
+  + Instance-based authorization on app service calls does not consider custom `WHERE` clauses of `UPDATE`/`DELETE` queries
+    + Until `@sap/cds^9`, this change can be deactivated via `cds.env.features.compat_restrict_where = true`
+  + Simple static clauses (e.g., `$user.level > 5`) are no longer evaluated by the server but added to the respective SQL regardless. As a result, requests may receive a response of `2xx` with an empty body instead of a `403`.
+    + Until `@sap/cds^9`, this change can be deactivated via `cds.env.features.compat_static_auth = true`
+  + Read restrictions on the entity are no longer taken into consideration when evaluating restrictions on bound actions/ functions
+    + Until `@sap/cds^9`, this change can be deactivated via `cds.env.features.compat_restrict_bound = true`
+
+### Fixed
+
+- ETag calculation if column was provided as Javascript Date
+- Forwarding of `/$count` queries while mocking the external service
+- Resolving of implicit function parameters (e.g `GET .../test.foo?x='bar'`)
+- Arrayed elements are not part of response unless explicitly selected with `$select`
+- In case of nonexistent user attributes (`$user.X`), only the subclause gets substituted with `false`
+- `@odata.context` in new OData adapter:
+  + Fixed crash for requests to actions/functions when `cds.env.odata.context_with_columns` is enabled
+  + Aggregation functions with `$apply` are now returned when `cds.env.odata.context_with_columns` is enabled
+  + `@odata.context` is now the first property in the response values of `concat` requests
+  + Binary key values are now properly encoded and formatted
+  + Fixed keys appearing as `(undefined)` for updates via navigation to-one
+  + Fixed key value pairs being returned as `undefined=undefined` for property access of aspects
+  + Backlinks no longer appear as keys for property access of aspects
+  + Non-anonymous structured types are now prefixed with the service name
+  + Structured types no longer end with `/$entity`
+
+## Version 8.5.1 - 2024-12-06
+
+### Fixed
+
+- `cds deploy --dry --model-only` no longer tries to load a SQLite database
+- Requests with HTTP methods other than `POST` to the `/$batch` endpoint are now rejected when using the new OData adapter
 
 ## Version 8.5.0 - 2024-11-25
 
@@ -515,7 +566,7 @@
 - Support for `@odata.draft.bypass` to allow direct modifications of active instances.
 - `req.user.tokenInfo` for `@sap/xssec`-based authentication (`ias`, `jwt`, `xsuaa`)
 - `cds.fiori.draft_lock_timeout` as successor of `cds.drafts.cancellationTimeout`.
-  + Possible values are /^([0-9]+)(h|hrs|min)$/ or a number in milliseconds.
+  + Possible values are `/^([0-9]+)(h|hrs|min)$/` or a number in milliseconds.
 - There is a new `sap.common.Timezones` entity with a basic time zone definition. There will be accompanying data in package `@sap/cds-common-content`.
 - Deprecation warnings for configuration options `cds.drafts.cancellationTimeout`, `cds.features.serve_on_root`, `cds.features.stream_compat`, `cds.fiori.lean_draft` and `cds.requires.middlewares`, as well as for the properties `req.user.locale` and `req.user.tenant`. The deprecation warnings can be turned off by setting `cds.features.deprecated` to `off`.
 

package/_i18n/i18n.properties

@@ -44,7 +44,7 @@ Currency=Currency
 CurrencyCode=Currency Code
 
 #XTIT: Currency Code Description
-CurrencyCode.Description=A currency code as specified in ISO 4217
+CurrencyCode.Description=Currency code as specified by ISO 4217
 
 #XTIT: Currency Symbol
 CurrencySymbol=Currency Symbol
@@ -59,7 +59,7 @@ Country=Country/Region
 CountryCode=Country/Region Code
 
 #XTIT: Country/Region Code Description
-CountryCode.Description=A country/region code as specified in ISO 3166-1
+CountryCode.Description=Country/region code as specified by ISO 3166-1
 
 #XTIT: Language
 Language=Language
@@ -68,10 +68,7 @@ Language=Language
 LanguageCode=Language Code
 
 #XTIT: Language Code Description
-LanguageCode.Description=A language code as specified in ISO 639-1
-
-#XTIT Time zone code
-TimeZoneCode=Time Zone Code
+LanguageCode.Description=Language code as specified by ISO 639-1
 
 #XTIT: User Identifier
 UserID=User ID
@@ -83,7 +80,7 @@ Name=Name
 Description=Description
 
 #XTOL: A user's unique Indentifier
-UserID.Description=A user's unique ID
+UserID.Description=User's unique ID
 
 #XTIT: Admin data for a draft document
 Draft_DraftAdministrativeData=Draft Administrative Data

package/eslint.config.mjs

@@ -27,8 +27,8 @@ export const defaults = {
       CXL: 'readonly',
 
       // subset of Node.js globals ...
-      __dirname: 'readonly',
       __filename: 'readonly',
+      __dirname: 'readonly',
       exports: 'writable',
       require: 'readonly',
       global: 'readonly',

package/lib/compile/etc/properties.js

@@ -9,14 +9,14 @@ function read (res, ext = '.properties') {
     // unicode chars in them (e.g.German umlauts), so let's parse in utf-8.
     if (!/\.(env|.+rc)$/.test(res) && !path.extname(res)) res += ext
     const src = fs.readFileSync(path.resolve(res),'utf-8')
-    const properties = src.match(/^\s*{/) ? JSON.parse(src) : Properties.parse(src)
-    return Object.defineProperty (properties, '_source', {value:res})
+    return Object.defineProperty (Properties.parse(src), '_source', {value:res})
   } catch (e) {
     if (e.code !== 'ENOENT') throw new Error (`Corrupt ${ext} file: ${res+ext}`)
   }
 }
 
 function parse (props) {
+  if (props.match(/^\s*{/)) return JSON.parse(props)
   const lines = props.split(/(?<![\\\r])\r?\n/)
   const rows = lines.filter(each => !!each.trim()).map(each => each.replace(/\\\r?\n/, '')).map(each => {
     const index = each.indexOf('=')

package/lib/compile/for/java.js

@@ -1,6 +1,7 @@
 // The only entry point to produce CSNs consumed by the Java Runtime
 
 const cds = require ('../../index')
+const TRACE = cds.debug('trace')
 
 function _4java (csn,o) {
   const compile = require ('../cdsc');
@@ -18,9 +19,7 @@ function _4java_tmp (csn,o) { // as long as compile.for.java is not definitely t
   return _4draft (dsn, o);
 }
 
-module.exports = function cds_compile_for_java (csn,o) {
-  if ('_4java' in csn) return csn._4java
-  // cds.minify (csn) ?
+function _compile_for_java (csn,o) {
   const dsn = (!cds.env.features._ucsn_) ? cds.compile.for.odata (csn,o||{}) : _4java (csn,o||{});
   if (dsn.definitions) for (let [name,d] of Object.entries(dsn.definitions)) {
     // Add @cds.external to external services
@@ -35,3 +34,16 @@ module.exports = function cds_compile_for_java (csn,o) {
   Object.defineProperty (dsn, '_4java', {value:dsn})
   return dsn
 }
+
+
+module.exports = function cds_compile_for_java (csn,o) {
+  if ('_4java' in csn) return csn._4java
+  TRACE?.time('cds.compile 4java'.padEnd(22))
+  try {
+    // csn = cds.minify (csn)
+    let result, next = ()=> result ??= _compile_for_java (csn,o)
+    cds.emit ('compile.for.runtime', csn, o, next)
+    return next() //> in case no handler called next
+  }
+  finally { TRACE?.timeEnd('cds.compile 4java'.padEnd(22)) }
+}

package/lib/compile/for/lean_drafts.js

@@ -19,6 +19,48 @@ function _isCompositionBacklink(e) {
   }
 }
 
+
+// NOTE: Keep outside of the function to avoid calling the parser repeatedly
+const { Draft } = cds.linked(`
+  entity ActiveEntity { key ID: UUID; }
+  entity Draft {
+    virtual IsActiveEntity            : Boolean; // REVISIT: these are calculated fields, aren't they?
+    virtual HasDraftEntity            : Boolean; // REVISIT: these are calculated fields, aren't they?
+    HasActiveEntity                   : Boolean; // This should be written !!!
+    DraftAdministrativeData           : Association to DRAFT.DraftAdministrativeData;
+    DraftAdministrativeData_DraftUUID : UUID;
+    // SiblingEntity                  : Association to ActiveEntity; // REVISIT: Why didn't we use a managed assoc here?
+  }
+  entity DRAFT.DraftAdministrativeData {
+    key DraftUUID         : UUID;
+    LastChangedByUser     : String(256);  LastChangeDateTime : Timestamp;
+    CreatedByUser         : String(256);  CreationDateTime   : Timestamp;
+    InProcessByUser       : String(256);
+    DraftIsCreatedByMe    : Boolean; // REVISIT: these are calculated fields, aren't they?
+    DraftIsProcessedByMe  : Boolean; // REVISIT: these are calculated fields, aren't they?
+  }
+`).definitions
+
+
+function DraftEntity4 (active, name = active.name+'.drafts') {
+
+  const draft = Object.create (active, {
+    name: { value: name }, // REVISIT: lots of things break if we do that!
+    elements: { value: { ...active.elements, ...Draft.elements }, enumerable: true },
+    actives: { value: active },
+    query: { value: undefined }, // to not inherit that from active
+    // drafts: { value: undefined }, // to not inherit that from active -> doesn't work yet as the coding in lean-draft.js uses .drafts to identify both active and draft entities
+    isDraft: { value: true },
+  })
+
+  // for quoted names, we need to overwrite the cds.persistence.name of the derived, draft entity
+  const _pname = active['@cds.persistence.name']
+  if (_pname) draft['@cds.persistence.name'] = _pname + '_drafts'
+
+  return draft
+}
+
+
 module.exports = function cds_compile_for_lean_drafts(csn) {
   function _redirect(assoc, target) {
     assoc.target = target.name
@@ -26,54 +68,22 @@ module.exports = function cds_compile_for_lean_drafts(csn) {
   }
 
   function _isDraft(def) {
+    // return 'DraftAdministrativeData' in def.elements
     return (
       def.associations?.DraftAdministrativeData ||
       (def.own('@odata.draft.enabled') && def.own('@Common.DraftRoot.ActivationAction'))
     )
   }
 
-  const { Draft } = cds.linked(`
-    entity ActiveEntity { key ID: UUID; }
-    entity Draft {
-      virtual IsActiveEntity            : Boolean; // REVISIT: these are calculated fields, aren't they?
-      virtual HasDraftEntity            : Boolean; // REVISIT: these are calculated fields, aren't they?
-      HasActiveEntity                   : Boolean; // This should be written !!!
-      DraftAdministrativeData           : Association to DRAFT.DraftAdministrativeData;
-      DraftAdministrativeData_DraftUUID : UUID;
-      // SiblingEntity                  : Association to ActiveEntity; // REVISIT: Why didn't we use a managed assoc here?
-    }
-    entity DRAFT.DraftAdministrativeData {
-      key DraftUUID         : UUID;
-      LastChangedByUser     : String(256);  LastChangeDateTime : Timestamp;
-      CreatedByUser         : String(256);  CreationDateTime   : Timestamp;
-      InProcessByUser       : String(256);
-      DraftIsCreatedByMe    : Boolean; // REVISIT: these are calculated fields, aren't they?
-      DraftIsProcessedByMe  : Boolean; // REVISIT: these are calculated fields, aren't they?
-    }
-  `).definitions
-
   function addDraftEntity(active, model) {
     const _draftEntity = active.name + '.drafts'
     const d = model.definitions[_draftEntity]
     if (d) return d
     // We need to construct a fake draft entity definition
     // We cannot use new cds.entity because runtime aspects would be missing
-    const draft = {
-      __proto__: active,
-      name: _draftEntity,
-      elements: { ...active.elements, ...Draft.elements },
-      query: undefined
-    }
-
-    // for quoted names, we need to overwrite the cds.persistence.name of the derived, draft entity
-    if (active['@cds.persistence.name'])
-      draft['@cds.persistence.name'] = active['@cds.persistence.name'] + '_drafts'
-    
+    const draft = new DraftEntity4 (active, _draftEntity)
     Object.defineProperty(model.definitions, _draftEntity, { value: draft })
     Object.defineProperty(active, 'drafts', { value: draft })
-    Object.defineProperty(active, 'actives', { value: active })
-    Object.defineProperty(draft, 'actives', { value: active })
-    Object.defineProperty(draft, 'isDraft', { value: true })
 
     // Positive list would be bigger (search, requires, fiori, ...)
     if (draft['@readonly']) draft['@readonly'] = undefined

package/lib/compile/for/nodejs.js

@@ -2,16 +2,25 @@ const { unfold_csn } = require ('../etc/_localized')
 const cds = require ('../../index')
 const TRACE = cds.debug('trace')
 
-module.exports = function cds_compile_for_nodejs (csn,o) {
-  if ('_4nodejs' in csn) return csn._4nodejs
-  TRACE?.time('cds.compile 4nodejs'.padEnd(22))
-  let dsn = csn // cds.minify (csn)
-  dsn = cds.compile.for.odata (csn,o) //> creates a partial copy -> avoid any cds.linked() before
-  dsn = unfold_csn (dsn)
-  dsn = cds.linked (dsn)
+
+function _compile_for_nodejs (csn, o) {
+  let min = cds.minify (csn)
+  let dsn = cds.compile.for.odata(min, o) //> creates a partial copy -> avoid any cds.linked() before
+  dsn = unfold_csn(dsn)
+  dsn = cds.linked(dsn)
   cds.compile.for.lean_drafts(dsn, o)
-  Object.defineProperty (csn, '_4nodejs', {value:dsn})
-  Object.defineProperty (dsn, '_4nodejs', {value:dsn})
-  TRACE?.timeEnd('cds.compile 4nodejs'.padEnd(22))
+  Object.defineProperty(csn, '_4nodejs', { value: dsn })
+  Object.defineProperty(dsn, '_4nodejs', { value: dsn })
   return dsn
 }
+
+
+module.exports = function cds_compile_for_nodejs (csn,o) {
+  if ('_4nodejs' in csn) return csn._4nodejs
+  TRACE?.time('cds.compile 4nodejs'.padEnd(22)); try {
+    let result, next = ()=> result ??= _compile_for_nodejs (csn,o)
+    cds.emit ('compile.for.runtime', csn, o, next)
+    return next() //> in case no handler called next
+  }
+  finally { TRACE?.timeEnd('cds.compile 4nodejs'.padEnd(22)) }
+}

package/lib/compile/minify.js

@@ -3,7 +3,7 @@ const DEBUG = cds.debug('minify')
 
 module.exports = function cds_minify (csn, roots = cds.env.features.skip_unused) {
   if (roots === false) return csn
-  if (csn[_minified]) return csn
+  if ((csn.meta??={}).minified) return csn
   const all = csn.definitions, reached = new Set
   if (roots === 'services') {
     for (let n in all) if (all[n].kind === 'service') _visit_service(n)
@@ -58,8 +58,6 @@ module.exports = function cds_minify (csn, roots = cds.env.features.skip_unused)
   const minified = csn, less = minified.definitions = {}
   for (let n in all) if (reached.has(all[n])) less[n] = all[n]
   else DEBUG?.('skipping', all[n].kind, n)
-  Object.defineProperty (minified,_minified,{value:true})
+  ;(minified.meta??={}).minified = true
   return minified
 }
-
-const _minified = Symbol('minified')

package/lib/compile/parse.js

@@ -1,86 +1,120 @@
 const cdsc = require ('@sap/cds-compiler')
 const cds = require ('../index')
 
-/** cds.parse is both, a namespace and a shortcut for cds.parse.cdl */
-const cds_parse = (src,o) => cds.compile (src,o,'parsed')
-const parse = module.exports = Object.assign (cds_parse, {
+const parse = module.exports = exports = (...args) => parse.cdl (...args)
 
-  CDL: (...args) => tagged(parse.cdl, ...args),
-  CQL: (...args) => tagged(parse.cql, ...args),
-  CXL: (...args) => tagged(parse.expr, ...args),
+exports.cdl = function cdl (x,...etc) {
+  if (x.raw) return parse.ttl (cdl, x,...etc)
+  else return cds.compile (x, etc[0], 'parsed')
+}
+
+exports.cql = function cql (x,...etc) { try {
+  if (x.raw) return parse.ttl (cql, x,...etc)
+  // add missing 'from' clause if not present -> REVISIT: this is a hack unless compiler accepts partial cql
+  const from = x.match(/ from /i); if (!from) x = x.replace(/( where | having | group by | order by | limit |$)/i, x => ' from $' + x)
+  const cqn = cdsc.parse.cql(x,undefined,{ messages:[], ...etc[0] })
+  if (!from) delete cqn.SELECT.from
+  return cqn
+} catch(e) {
+  // cds-compiler v5 does not put messages into `e.message` anymore; render them explicitly
+  e.message = !e.messages ? e.message : e.toString();
+  e.message = e.message.replace('<query>.cds:',`In '${e.cql = x}' at `)
+  throw e // with improved error message
+}}
 
-  cdl: cds_parse,
-  cql: (x,o) => { try { return cdsc.parse.cql(x,undefined,{ messages:[],  ...o }) } catch(e) {
+exports.path = function path (x,...etc) {
+  if (x.raw) return parse.ttl (path, x,...etc)
+  if (cds.model?.definitions[x]) return {ref:[x]}
+  if (/^([\w_.$]+)$/.test(x)) return {ref:[x]} // optimized parsing of simple paths of length 1
+  const [,head,tail] = /^([\w._]+)(?::(\w+))?$/.exec(x)||[]
+  if (tail) return {ref:[head,...tail.split('.')]}
+  if (head) return {ref:[head]}
+  const {SELECT} = cdsc.parse.cql('SELECT from '+x)
+  return SELECT.from
+}
+
+exports.expr = function expr (x,...etc) {
+  if (x.raw) return parse.ttl (expr, x,...etc)
+  if (typeof x !== 'string') throw cds.error.expected `${{x}} to be an expression string`
+  if (x in globals) return globals[x]                      // optimized parsing of true, false, null
+  if (/^([\d.]+)$/.test(x)) return {val:Number(x)}        // optimized parsing of numeric vals
+  if (/^([\w_$]+)$/.test(x)) return {ref:[x]}            // optimized parsing of simple refs of length 1
+  if (/^([\w_.$]+)$/.test(x)) return {ref:x.split('.')} // optimized parsing of simple refs of length > 1
+  try { return cdsc.parse.expr(x,undefined,{ messages:[], ...etc[0] }) } catch(e) {
     // cds-compiler v5 does not put messages into `e.message` anymore; render them explicitly
     e.message = !e.messages ? e.message : e.toString();
-    e.message = e.message.replace('<query>.cds:',`In '${e.cql = x}' at `)
+    e.message = e.message.replace('<expr>.cds:1:',`In '${e.expr = x}' at `)
     throw e // with improved error message
-  }},
-  path: (x,...values) => {
-    if (x && x.raw) return tagged (parse.path,x,...values)
-    if (/^[A-Za-z_0-9.$]*$/.test(x)) return {ref:[x]}
-    if ((cds.context?.model || cds.model)?.definitions[x]) return {ref:[x]}
-    let {SELECT} = parse.cql('SELECT from '+x)
-    return SELECT.from
-  },
-  column: x => {
-    let as = /\s+as\s+(\w+)$/i.exec(x)
-    if (as) {
-      let col = parse.expr(x.slice(0,as.index)); col.as = as[1]
-      return col
-    }
-    else return parse.expr(x)
-  },
-  expr: (x,o) => {
-    if (typeof x !== 'string') throw cds.error.expected `${{x}} to be an expression string`
-    if (x in keywords) return {ref:[x]}
-    try { return cdsc.parse.expr(x,undefined,{ messages:[], ...o }) } catch(e) {
-      // cds-compiler v5 does not put messages into `e.message` anymore; render them explicitly
-      e.message = !e.messages ? e.message : e.toString();
-      e.message = e.message.replace('<expr>.cds:1:',`In '${e.expr = x}' at `)
-      throw e // with improved error message
-    }
-  },
-  xpr: x => { const y = parse.expr(x); return y.xpr || [y] },
-  ref: x => parse.expr(x).ref,
-
-  properties: (...args) => (parse.properties = require('./etc/properties').parse) (...args),
-  yaml: (...args) => (parse.yaml = require('./etc/yaml').parse) (...args),
-  csv: (...args) => (parse.csv = require('./etc/csv').parse) (...args),
-  json: (...args) => JSON.parse (...args),
-
-})
-
-
-const tagged = (parse, strings, ...values) => {
-  if (!strings.raw) return parse (strings, ...values)
-  if (!strings.length) return parse (strings[0])
-  const all = new Array (strings.length + values.length)
-  for (var i=0; i<strings.length-1; ++i) {
-    let v = values[i], s = strings[i]
-    all[2*i] = s
-    all[2*i+1] = v instanceof cds.entity ? v.name : ':'+i
-    if (typeof v === 'string' && s.endsWith(' like ') && !v.includes('%')) values[i] = `%${v}%`
-    if (Array.isArray(v) && s.toLowerCase().endsWith(' in ')) values[i] = {list: v.map(cxn4)}
   }
-  all[2*i] = strings[i]
-  return merge (parse(all.join('')), values)
 }
 
-const merge = (o,values) => {
-  for (let k in o) {
-    const x = o[k]
-    if (!x) continue
-    if (x.param) {
-      let val = values[x.ref[0]]; if (val === undefined) continue
-      let y = o[k] = cxn4(val)
-      if (x.cast) y.cast = x.cast
-      if (x.key) y.key = x.key
-      if (x.as) y.as = x.as
-    } else if (typeof x === 'object') merge(x,values)
+exports.xpr = (...args) => {
+  const y = parse.expr (...args)
+  return y.xpr || [y]
+}
+
+exports.ref = (x,...etc) => {
+  const ntf = {null:{val:null},true:{val:true},false:{val:false}}[x]; if (ntf) return ntf
+  if (/^[A-Za-z_$][\w.]*$/.test(x)) return { ref: x.split('.') }
+  else return parse.expr (x,...etc)
+}
+
+exports.properties = (...args) => (parse.properties = require('./etc/properties').parse) (...args)
+exports.yaml = (...args) => (parse.yaml = require('./etc/yaml').parse) (...args)
+exports.csv = (...args) => (parse.csv = require('./etc/csv').parse) (...args)
+exports.json = (...args) => JSON.parse (...args)
+
+
+exports.ttl = (parse, strings, ...values) => {
+
+  // Reusing cached results for identical template strings w/o values
+  // if (!values.length) {
+  //   const cache = _parse_ttl.cache ??= new WeakMap
+  //   if (cache.has(strings)) return cache.get(strings)
+  //   let parsed = parse (strings[0])
+  //   cache.set(strings,parsed)
+  //   return parsed
+  // }
+
+  let cql = values.reduce ((cql,v,i) => {
+    if (Array.isArray(v) && strings[i].match(/ in $/i)) values[i] = { list: v.map(cxn4) }
+    return cql + strings[i] + (v instanceof cds.entity ? v.name : ':'+i)
+  },'') + strings.at(-1)
+  const cqn = parse (cql) //; cqn.$params = values
+  return merge (cqn, values)
+
+  function merge (o,values) {
+    for (let k in o) {
+      const x = o[k]
+      if (!x) continue
+      if (x.param) {
+        let val = values[x.ref[0]]; if (val === undefined) continue
+        let y = o[k] = cxn4(val) //; y.$ = x.ref[0]
+        if (x.cast) y.cast = x.cast
+        if (x.key) y.key = x.key
+        if (x.as) y.as = x.as
+      } else if (typeof x === 'object') merge(x,values)
+    }
+    return o
   }
-  return o
 }
 
-const cxn4 = x => x.SELECT || x.ref || x.xpr || x.val !== undefined|| x.list || x.func ? x : {val:x}
-const keywords = { KEY:1, key:1, SELECT:1, select:1 }
+
+/** @protected */
+exports._select = (prefix, ttl, suffix) => {
+  let [ strings, ...values ] = ttl; strings = [...strings]; strings.raw = strings; // need that as ttl strings are sealed
+  if (prefix) strings[0] = `SELECT ${prefix} ${strings[0]}`; else strings[0] = `SELECT ${strings[0]}`
+  if (suffix) strings[strings.length-1] += ` ${suffix}`
+  return cds.parse.cql (strings, ...values).SELECT
+}
+
+const is_cqn = x => typeof x === 'object' && (
+  'ref' in x ||
+  'val' in x ||
+  'xpr' in x ||
+  'list' in x ||
+  'func' in x ||
+  'SELECT' in x
+)
+const cxn4 = x => is_cqn(x) ? x : {val:x}
+const globals = { true: {val:true}, false: {val:false}, null: {val:null} }

package/lib/compile/to/edm.js

@@ -1,5 +1,6 @@
 const cdsc = require ('../cdsc')
 const cds = require ('../../index')
+const TRACE = cds.debug('trace')
 
 if (cds.env.features.precompile_edms !== false) {
   const _precompiled = new WeakMap
@@ -18,21 +19,30 @@ if (cds.env.features.precompile_edms !== false) {
 function cds_compile_to_edm (csn,_o) {
   const o = cdsc._options.for.edm(_o) //> used twice below...
   csn = _4odata(csn,o)
-  if (o.service === 'all') return _many ('.json',
-    cdsc.to.edm.all (csn,o),
-    o.as === 'str' ? JSON.stringify : x=>x
-  )
-  else return cdsc.to.edm (csn,o)
+  TRACE?.time('cds.compile 2edm'.padEnd(22))
+  try {
+    let result, next = ()=> result = o.service === 'all' ? _many ('.json',
+      cdsc.to.edm.all (csn,o), o.as === 'str' ? JSON.stringify : x=>x
+    ) : cdsc.to.edm (csn,o)
+    cds.emit ('compile.to.edmx', csn, o, next) // NOTE: intentionally using same event as for edmx
+    return result ??= next() //> in case no handler called next
+  }
+  finally { TRACE?.timeEnd('cds.compile 2edm'.padEnd(22)) }
 }
 
 
 function cds_compile_to_edmx (csn,_o) {
   const o = cdsc._options.for.edm(_o) //> used twice below...
   csn = _4odata(csn,o)
-  if (o.service === 'all') return _many ('.xml',
-    cdsc.to.edmx.all (csn,o)
-  )
-  else return cdsc.to.edmx (csn,o)
+  TRACE?.time('cds.compile 2edmx'.padEnd(22))
+  try {
+    let result, next = ()=> result ??= o.service === 'all' ? _many ('.xml',
+      cdsc.to.edmx.all (csn,o)
+    ) : cdsc.to.edmx (csn,o)
+    cds.emit ('compile.to.edmx', csn, o, next)
+    return next() //> in case no handler called next
+  }
+  finally { TRACE?.timeEnd('cds.compile 2edmx'.padEnd(22)) }
 }
 
 

package/lib/compile/to/hana.js

@@ -1,27 +1,31 @@
 const cds = require('../..')
 const cdsc = require('../cdsc')
+const TRACE = cds.debug('trace')
 
 module.exports = (csn, o, beforeCsn) => {
-  if (typeof beforeCsn === 'string') beforeCsn = JSON.parse(beforeCsn)
-
-  const { definitions, deletions, migrations, afterImage } = cdsc.to.hdi.migration(cds.minify(csn), o, beforeCsn)
-  let migrationResult = false
-  if (beforeCsn || Object.values(afterImage.definitions).some(def => def['@cds.persistence.journal'])) {
-    migrationResult = true
+  TRACE?.time('cds.compile 2hana'.padEnd(22))
+  try {
+    let result, next = ()=> result ??= function* (){
+      csn = cds.minify (csn)
+      const { definitions, deletions, migrations, afterImage } = cdsc.to.hdi.migration (csn, o,
+        typeof beforeCsn === 'string' ? beforeCsn = JSON.parse(beforeCsn) : beforeCsn
+      )
+      for (const { name, suffix, sql } of definitions) {
+        yield [sql, { file: name + suffix }]
+      }
+      if (deletions.length > 0) {
+        yield [deletions, { file: 'deletions.json' }]
+      }
+      if (migrations.length > 0) {
+        yield [migrations, { file: 'migrations.json' }]
+      }
+      let needsAfterImage = beforeCsn || Object.values(afterImage.definitions).some(def => def['@cds.persistence.journal'])
+      if (needsAfterImage) {
+        yield [afterImage, { file: 'afterImage.json' }]
+      }
+    }()
+    cds.emit ('compile.to.dbx', csn, o, next)
+    return next() //> in case no handler called next
   }
-
-  return (function* () {
-    for (const { name, suffix, sql } of definitions) {
-      yield [sql, { file: name + suffix }]
-    }
-    if (deletions.length > 0) {
-      yield [deletions, { file: 'deletions.json' }]
-    }
-    if (migrations.length > 0) {
-      yield [migrations, { file: 'migrations.json' }]
-    }
-    if (migrationResult) {
-      yield [afterImage, { file: 'afterImage.json' }]
-    }
-  })()
+  finally { TRACE?.timeEnd('cds.compile 2hana'.padEnd(22)) }
 }