@sap/cds-dk 9.9.3 → 10.0.4

package/node_modules/@sap/cds/lib/compile/for/lean_drafts.js

@@ -0,0 +1,230 @@
+const cds = require('../../index')
+
+function _getBacklinkName(on) {
+  const i = on.findIndex(e => e.ref && e.ref[0] === '$self')
+  if (i === -1) return
+  let ref
+  if (on[i + 1] && on[i + 1] === '=') ref = on[i + 2].ref
+  if (on[i - 1] && on[i - 1] === '=') ref = on[i - 2].ref
+  return ref && ref[ref.length - 1]
+}
+
+function _isCompositionBacklink(e) {
+  if (!e.isAssociation) return
+  if (!e._target?.associations) return
+  if (!(!e.isComposition && (e.keys || e.on))) return
+  for (const anchor of Object.values(e._target.associations)) {
+    if (!(anchor.isComposition && anchor.on?.length > 2)) continue
+    if (_getBacklinkName(anchor.on) === e.name && anchor.target === e.parent.name) return anchor
+  }
+}
+
+// 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') {
+  // skip compositions with @odata.draft.enabled: false
+  const active_elements = {}
+  for (const each in active.elements) {
+    const element = active.elements[each]
+    if (element.isComposition && element['@odata.draft.enabled'] === false) {
+      // exclude, i.e., do nothing
+    } else {
+      active_elements[each] = element
+    }
+  }
+
+  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'
+
+  if (cds.env.fiori.calc_elements !== false) {
+    for (const each in draft.elements) {
+      const element = draft.elements[each]
+      // $calc = true indicates that the compiler cannot determine the calculated expression
+      if (element.$calc && element.$calc !== true) {
+        const e = { __proto__: element }
+        e.value = element.$calc
+        draft.elements[each] = e
+      }
+    }
+  }
+
+  return draft
+}
+
+module.exports = function cds_compile_for_lean_drafts(csn) {
+  function _redirect(assoc, target) {
+    assoc.target = target.name
+    assoc._target = target
+  }
+
+  function _isDraft(def) {
+    // return 'DraftAdministrativeData' in def.elements
+    return (
+      def.associations?.DraftAdministrativeData ||
+      (def.own('@odata.draft.enabled') && def.own('@Common.DraftRoot.ActivationAction'))
+    )
+  }
+
+  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 = new DraftEntity4(active, _draftEntity)
+    Object.defineProperty(model.definitions, _draftEntity, { value: draft })
+    Object.defineProperty(active, 'drafts', { value: draft })
+
+    // Positive list would be bigger (search, requires, fiori, ...)
+    if (draft['@readonly']) draft['@readonly'] = undefined
+    if (draft['@insertonly']) draft['@insertonly'] = undefined
+    if (draft['@restrict']) {
+      const restrictions = ['CREATE', 'WRITE', '*']
+      draft['@restrict'] = draft['@restrict']
+        .map(d => ({
+          ...d,
+          grant:
+            d.grant && Array.isArray(d.grant)
+              ? d.grant.filter(g => restrictions.includes(g))
+              : typeof d.grant === 'string' && restrictions.includes(d.grant)
+              ? [d.grant]
+              : []
+        }))
+        .filter(r => r.grant.length > 0)
+      if (draft['@restrict'].length > 0) {
+        // Change WRITE & CREATE to NEW
+        draft['@restrict'] = draft['@restrict'].map(d => {
+          if (d.grant.includes('WRITE') || d.grant.includes('CREATE')) {
+            return { ...d, grant: 'NEW' }
+          }
+          return d
+        })
+      } else {
+        draft['@restrict'] = undefined
+      }
+    }
+    if ('@Capabilities.DeleteRestrictions.Deletable' in draft)
+      draft['@Capabilities.DeleteRestrictions.Deletable'] = undefined
+    if ('@Capabilities.InsertRestrictions.Insertable' in draft)
+      draft['@Capabilities.InsertRestrictions.Insertable'] = undefined
+    if ('@Capabilities.UpdateRestrictions.Updatable' in draft)
+      draft['@Capabilities.UpdateRestrictions.Updatable'] = undefined
+    if ('@Capabilities.NavigationRestrictions.RestrictedProperties' in draft)
+      draft['@Capabilities.NavigationRestrictions.RestrictedProperties'] = undefined
+
+    // Recursively add drafts for compositions
+    for (const each in draft.elements) {
+      const e = draft.elements[each]
+
+      // add @odata.draft.enclosed to filtered compositions
+      if (e.$enclosed) {
+        e['@odata.draft.enclosed'] = true
+      }
+
+      const newEl = Object.create(e)
+      if (
+        e.isComposition ||
+        (e.isAssociation && e['@odata.draft.enclosed']) ||
+        ((!active['@Common.DraftRoot.ActivationAction'] || e._target === active) && _isCompositionBacklink(e) && _isDraft(e._target))
+      ) {
+        if (e._target['@odata.draft.enabled'] === false) continue // happens for texts if @fiori.draft.enabled is not set
+        _redirect(newEl, addDraftEntity(e._target, model))
+      }
+
+      if (e.name === 'DraftAdministrativeData') {
+        // redirect to DraftAdministrativeData service entity
+        if (active._service?.entities.DraftAdministrativeData) _redirect(newEl, active._service.entities.DraftAdministrativeData)
+      }
+
+      Object.defineProperty(newEl, 'parent', { value: draft, enumerable: false, configurable: true, writable: true })
+
+      for (const key in newEl) {
+        if (
+          key === '@mandatory' ||
+          (key === '@Common.FieldControl' && newEl[key]?.['#'] === 'Mandatory') ||
+          // key === '@Core.Immutable': Not allowed via UI anyway -> okay to cleanse them in PATCH
+          // REVISIT: Remove feature flag dependency: If active, validation errors will be degraded to messages and stored in draft admin data
+          (!active._service?.entities.DraftAdministrativeData.elements.DraftMessages && key.startsWith('@assert')) ||
+          key.startsWith('@PersonalData')
+        )
+          newEl[key] = undefined
+      }
+
+      draft.elements[each] = newEl
+    }
+
+    // For list-report hierarchies, there must not be deep deletes w.r.t. recursive compositions
+    // Therefore, they are degraded to associations.
+    // Note: For object-page hiearchies, deep delete on draft recursive compositions is still needed.
+    if (draft.elements.LimitedDescendantCount && draft['@Common.DraftRoot.ActivationAction']) {
+      for (const c in draft.compositions) {
+        const comp = draft.compositions[c]
+        if (comp.target === draft.name) {
+          // modify comp to assoc
+          comp.type = 'cds.Association'
+          comp.isComposition = false
+          comp.is = function(kind) { return kind === 'Association' }
+          delete draft.compositions[c]
+          draft.associations[c] = comp
+        }
+      }
+    }
+
+    return draft
+  }
+
+  for (const name in csn.definitions) {
+    const def = csn.definitions[name]
+
+    // Do nothing for entities that are not draft-enabled
+    if (!_isDraft(def) || def['@cds.external']) continue
+
+    // Mark elements as virtual as required
+    def.elements.IsActiveEntity.virtual = true
+    def.elements.HasDraftEntity.virtual = true
+    def.elements.HasActiveEntity.virtual = true
+    def.elements.DraftAdministrativeData.virtual = true
+    if (def.elements.DraftAdministrativeData_DraftUUID) def.elements.DraftAdministrativeData_DraftUUID.virtual = true
+
+    // For Hierarchies: Exclude recursive compoisitions from draft tree
+    if (def.elements.LimitedDescendantCount) {
+      // for hierarchies: make sure recursive compositions are not part of the draft tree
+      for (const c in def.compositions) {
+        const comp = def.compositions[c]
+        if (comp.target === def.name) comp['@odata.draft.ignore'] = true
+      }
+    }
+
+    // will insert drafts entities, so that others can use `.drafts` even without incoming draft requests
+    addDraftEntity(def, csn)
+  }
+}

package/node_modules/@sap/cds/lib/compile/for/nodejs.js

@@ -0,0 +1,94 @@
+const { unfold_csn } = require ('../etc/_localized')
+const cds = require ('../../index')
+const TRACE = cds.debug('trace')
+
+
+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)
+
+  // @Common.Text → @cds.search
+  text_to_search: for (const name in dsn.definitions) {
+    const def = dsn.definitions[name]
+    if (!def.associations) continue
+
+    // if any @cds.search.* === true, @Common.Text should be ignored
+    for (const key in def) if (key.startsWith('@cds.search') && def[key]) continue text_to_search
+
+    let isSearchAddedProgrammatically = false
+
+    // Add elements referenced in common.text annotations to search-relevant elements
+    for (const name in def.associations) {
+      const assoc = def.associations[name]
+
+      // Extract the reference value from the @Common.Text annotation
+      let annotationValue = assoc['@Common.Text']
+      if (!annotationValue) continue
+
+      // Extract the relevant label reference
+      let commonTextRef = annotationValue.ref
+      if (!commonTextRef) {
+        // For annotation expression values, '=' property is set to true or undefined
+        if (typeof annotationValue['='] !== 'string') continue
+        commonTextRef = annotationValue['='].split('.')
+      }
+
+      // Ignore empty references & those with more than two segments
+      if (commonTextRef.length < 1 || commonTextRef.length > 2) continue
+      
+      // Make sure the reference is not explicitly excluded from search
+      const commonTextValue = commonTextRef.join('.')
+      if (def[`@cds.search.${commonTextValue}`] === false) continue
+
+      if (commonTextRef.length === 1) {
+        const element = def.elements[commonTextRef[0]]
+        if (!element || element.target || element.items) continue
+      }
+
+      if (commonTextRef.length === 2) {
+        const association = def.associations[commonTextRef[0]]
+        if (!association) continue
+        
+        const associationTarget = dsn.definitions[association.target]
+        if (!associationTarget) continue
+        if (associationTarget['@cds.persistence.skip']) continue
+
+        const element = associationTarget.elements[commonTextRef[1]]
+        if (!element || element.target || element.items) continue
+      }
+
+      def[`@cds.search.${commonTextValue}`] = true
+      isSearchAddedProgrammatically = true
+    }
+
+    // add all string elements to @cds.search, if not annotated with @cds.search = false
+    if (isSearchAddedProgrammatically)
+      for (const el in def.elements) {
+        const search_el = def.elements[el]
+        if (search_el._type === 'cds.String' && def[`@cds.search.${search_el.name}`] !== false) {
+          def[`@cds.search.${search_el.name}`] = true
+        }
+      }
+  }
+
+  Object.defineProperty(csn, '_4nodejs', { value: dsn })
+  Object.defineProperty(dsn, '_4nodejs', { value: dsn })
+  Object.assign (dsn.meta, csn.meta, dsn.meta) // merge meta data, as it may have been enhanced
+  return dsn
+}
+
+
+module.exports = function cds_compile_for_nodejs (csn,o) {
+  if ('_4nodejs' in csn) return csn._4nodejs
+  // REVISIT: remove _compat_texts_entities with cds^11
+  if (cds.env.features.compat_texts_entities) Object.defineProperty(csn, '_compat_texts_entities', { value: true, enumerable: true })
+  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/node_modules/@sap/cds/lib/compile/for/odata.js

@@ -0,0 +1,19 @@
+const compile = require ('../cdsc')
+const cds = require('../../index')
+const TRACE = cds.debug('trace')
+
+module.exports = function cds_compile_for_odata (csn,_o) {
+  if ('_4odata' in csn) return csn._4odata
+  TRACE?.time('cds.compile 4odata'.padEnd(22))
+  let o = compile._options.for.odata(_o) //> required to inspect .sql_mapping below
+  let dsn = compile.for.odata (csn,o)
+  if (o.sql_mapping) dsn['@sql_mapping'] = o.sql_mapping //> compat4 old Java stack
+
+  if (cds.env.fiori.bypass_draft || cds.env.profiles.includes('java')) // Java always had bypass draft enabled
+    cds.compile.for.direct_crud(dsn)
+
+  Object.defineProperty (csn, '_4odata', {value:dsn})
+  Object.defineProperty (dsn, '_4odata', {value:dsn})
+  TRACE?.timeEnd('cds.compile 4odata'.padEnd(22))
+  return dsn
+}

package/node_modules/@sap/cds/lib/compile/for/sql.js

@@ -0,0 +1,9 @@
+/** REVISIT: Use `@sap/cds-compiler` if for_sql is made public. */
+const compile = require ('@sap/cds-compiler/lib/api/main')
+let _compile
+
+module.exports = function cds_compile_for_sql (src,o) {
+  _compile = _compile || compile.for_sql
+  // for_sql directly returns a CSN
+  return _compile(src,{...o,csn:true});
+}

package/node_modules/@sap/cds/lib/compile/load.js

@@ -0,0 +1,59 @@
+module.exports = exports = load
+exports.parsed = get
+
+const cds = require ('../index.js')
+const outbox_cds = cds.env.requires.queue?.model
+const [ outbox ] = cds.resolve (outbox_cds) || []
+
+const TRACE = cds.debug('trace')
+if (TRACE) {
+  TRACE?.time('require cds.compiler'.padEnd(22))
+  require('@sap/cds-compiler/lib/compiler')
+  TRACE?.timeEnd('require cds.compiler'.padEnd(22))
+}
+
+
+function load (models, options) {
+  const files = cds.resolve (models, options)
+  if (!files || cds.watched && files == outbox) return Promise.reject (new cds.error ({
+    message: `Couldn't find a CDS model for '${models}' in ${cds.root}`,
+    files: cds.resolve(models,false)?.filter (f => f !== outbox_cds),
+    code: 'MODEL_NOT_FOUND',
+  }))
+  return get (files, options, 'inferred') 
+}
+
+
+function get (files, options, _flavor) {
+  const o = typeof options === 'string' ? { flavor:options } : options || {}
+  if (!files) files = ['*']; else if (!Array.isArray(files)) files = [files]
+  if (o.files || o.flavor === 'files') return cds.resolve(files,o)
+  if (o.sources || o.flavor === 'sources') return _sources4 (cds.resolve(files,o))
+  if (!o.silent) TRACE?.time('cds.compile *.cds'.padEnd(22))
+
+  const csn = cds.compile (files,o,
+    o.parse  ? 'parsed' :
+    o.plain  ? 'xtended' :
+    o.clean  ? 'xtended' : // for compatibility
+    o.flavor || _flavor || 'parsed'
+  )
+  return csn.then?.(_finalize) || _finalize(csn)
+
+  function _finalize (csn) {
+    if (outbox) csn.$sources = csn.$sources.filter (f => f !== outbox)
+    if (!o.silent) cds.emit ('loaded', csn)
+    if (!o.silent) TRACE?.timeEnd('cds.compile *.cds'.padEnd(22))
+    return csn
+  }
+
+  async function _sources4 (files) {
+    const {relative} = cds.utils.path, {readFile} = cds.utils.fs.promises
+    const all = await Promise.all (files.map (f => readFile(f,'utf-8')))
+    return files.reduce ((d,f,i) => (d[relative(cds.root,f)] = all[i], d),{})
+  }
+}
+
+
+exports.properties = (...args) => (exports.properties = require('./etc/properties').read) (...args)
+exports.yaml = (...args) => (exports.yaml = require('./etc/yaml').read) (...args)
+exports.csv = (...args) => (exports.csv = require('./etc/csv').read) (...args)

package/node_modules/@sap/cds/lib/compile/minify.js

@@ -0,0 +1,112 @@
+module.exports = exports = (m,o) => m.meta?.minified ? m : (new Minifier) .minify (m,o)
+
+class Minifier {
+
+  /**
+   * Minifies a model by removing all definitions not reachable from given roots.
+   * @param {object} [options] - Options for the minification as follows...
+   * @param {kinds} [options.keep] Controls which children of services to keep.
+   * @param {string[]} [options.cleanse] Names of properties or annotations to be removed.
+   * @typedef {{ entity, aspect, type, event, action, function }} kinds
+   * @returns {CSN.Model} the minified model with kept definitions only.
+   */
+  minify (csn, options, { skip_unused } = global.cds.env.features) {
+
+    const o = this.options = options || {}
+    if (skip_unused === false) return csn
+    if (skip_unused === 'services') o.services = 'all'
+    const all = new Map (Object.entries( this.defs ??= csn.definitions || {} ))
+    const children = (n,fn,pre=n+'.') => { for (let [n,d] of all) if (n.startsWith(pre)) fn (n,d) }
+    const keep = (d,kinds) => d.kind in kinds || _can_minify(d)
+    const _own = o.keep ??= { entity:1, type:1, event:1, action:1, function:1 }
+    const _ext = { event:1, action:1, function:1 }
+    const kept = this.kept = csn.definitions = {}
+    const skipped = this.skipped = {}
+
+    if (o.services) {
+      // If o.services is specified, only keep matching services and their children
+      const rx = o.services == 'all' || o.services == '/all/i' ? {test:()=>true} : o.services
+      for (let [s,d] of all) if (d.kind === 'service' && rx.test(s)) {
+        this.keep(s,d); children (s, (c,d) => this.keep(c,d))
+      }
+    } else {
+      // Otherwise first mark all external services and their children as initially skipped
+      for (let [s,d] of all) if (d.kind === 'service' && _skip_service(s,d)) {
+        skipped[s] = 0; children (s, (c,d) => keep(d,_ext) ? this.keep(c,d,s) : skipped[c] = s) // used later on in this.keep()
+      }
+      // Then keep all own services and their children
+      for (let [s,d] of all) if (d.kind === 'service' && !(s in skipped)) {
+        this.keep(s,d); children (s, (c,d) => keep(d,_own) ? this.keep(c,d) : skipped[c] = 0)
+      }
+      // Also keep remaining non-service entities
+      for (let [e,d] of all) if (d.kind === 'entity' || !_can_minify(d)) {
+        e in kept || e in skipped || _skip_entity(e,d) || this.keep(e,d)
+      }
+    }
+
+    ;(csn.meta ??= {}) .minified = true
+    return csn
+  }
+
+  cleanse (d, o = this.options, keep = this._keep ??= Object.keys (o.keep)) {
+    for (let p in o.cleanse) {
+      if (p[0] !== '@') delete d[p] // a single property
+      for (let a in d) if (a.startsWith(p) && !keep.some(k => a.startsWith(k))) delete d[a]
+    }
+  }
+
+  walk (d) { this.cleanse(d)
+    if (d.target)             this.keep (d.target)              // has to go first w/o return for redirected targets
+    if (d.type in this.defs)  return this.keep (d.type)         // return to avoid endless recursion
+    if (d.type?.ref)          return this.keep (d.type.ref[0])  // return to avoid endless recursion
+    if (d.projection)         this.view (d.projection,d)
+    if (d.query)              this.view (d.query,d)
+    if (d.items)              this.walk (d.items)
+    if (d.returns)            this.walk (d.returns)
+    for (let e in d.elements) this.walk (d.elements[e])
+    for (let a in d.actions)  this.walk (d.actions[a])
+    for (let p in d.params)   this.walk (d.params[p])
+    for (let i in d.includes) this.keep (d.includes[i])
+  // Note: this ^^^^^^^^^^^^ is required for cdsc.recompile; with delete d.includes, redirects in AFC broke
+  }
+
+  view (q,v) {
+    if (q.SELECT) q = q.SELECT // i.e. entity as select from ...
+    if (q.mixin) for (let e in q.mixin) this.walk (q.mixin[e])
+    if (q.from?.ref) {
+      let r = q.from.ref[0]; if (r.id) r = r.id; if (r in this.kept) return
+      if (v?.['@cds.minify'] === 'unused-elements') return this.keep_columns (q)
+      else return this.keep (r) // keep sources of views
+    }
+    if (q.from?.join) return q.from.args.forEach (from => this.view ({from}))
+    if (q.SET) return q.SET.args.forEach (q => this.view (q.SELECT||q))
+  }
+
+  keep_columns (q) {
+    let r = q.from.ref[0]; if (r.id) r = r.id; if (r in this.kept) return
+    let e = this.defs[r]; if (!e) return
+    let all = e.elements, kept = {}
+    if (q.columns) _keep (q.columns)
+    if (q.where) _keep (q.where)
+    e.elements = kept
+    return this.keep (r,e)
+    function _keep (xx) { for (let x of xx) {
+      if (x.func) { _keep (x.args); continue }
+      if (x.xpr) { _keep (x.xpr); continue }
+      if (x.ref) { let [r] = x.ref; if (r in all) kept[r] = all[r] }
+    }}
+  }
+
+  keep (n,d,parent) {
+    if (n in this.kept) return; else d ??= this.defs[n]
+    if (d) this.walk (this.kept[n] = d, n); else return
+    let texts = this.defs[n+'.texts']; if (texts) this.keep (n+'.texts', texts)
+    let p = parent ?? this.skipped[n]; if (p) this.keep(p) // keep initially skipped services
+  }
+
+}
+
+const _skip_service = (s,d) => (d['@cds.external'] >= 2) && _can_minify(d)
+const _skip_entity = (e,d) => (d['@cds.external'] >= 2 || d['@cds.persistence.skip'] === 'if-unused') && _can_minify(d) || e.endsWith('.texts')
+const _can_minify = d => d['@cds.minify'] !== false
+exports.Minifier = Minifier

package/node_modules/@sap/cds/lib/compile/parse.js

@@ -0,0 +1,140 @@
+const cdsc = require ('@sap/cds-compiler')
+const cds = require ('../index')
+
+const parse = module.exports = exports = (...args) => parse.cdl (...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
+}}
+
+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, undefined, { messages: [] })
+  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 native[x] || {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('<expr>.cds:1:',`In '${e.expr = x}' at `)
+    throw e // with improved error message
+  }
+}
+
+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(/\sin\s*$/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 && x.ref) {
+        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
+  }
+}
+
+
+/** @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 native = {
+  current_date         : { func: 'current_date' },
+  current_time         : { func: 'current_time' },
+  current_timestamp    : { func: 'current_timestamp' },
+  current_user         : { func: 'current_user' },
+  current_utcdate      : { func: 'current_utcdate' },
+  current_utctime      : { func: 'current_utctime' },
+  current_utctimestamp : { func: 'current_utctimestamp' },
+  session_user         : { func: 'session_user' },
+  sysuuid              : { func: 'sysuuid' },
+  CURRENT_DATE         : { func: 'current_date' },
+  CURRENT_USER         : { func: 'current_user' },
+  CURRENT_TIME         : { func: 'current_time' },
+  CURRENT_TIMESTAMP    : { func: 'current_timestamp' },
+  CURRENT_UTCDATE      : { func: 'current_utcdate' },
+  CURRENT_UTCTIME      : { func: 'current_utctime' },
+  CURRENT_UTCTIMESTAMP : { func: 'current_utctimestamp' },
+  SESSION_USER         : { func: 'session_user' },
+  SYSUUID              : { func: 'sysuuid' },
+}
+const is_cqn = x => x !== null && 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} }