@sap/cds 5.9.6 → 6.0.1

package/lib/compile/for/java.js

@@ -1,16 +1,19 @@
 const cds = require ('../../index')
-const _cached = Symbol('for Java')
 
 module.exports = function cds_compile_for_java (csn,o) {
-  if (!csn) return
-  const cached = csn[_cached]; if (cached) return cached
-  // csn = cds.minify (csn)
-  csn = cds.compile.for.drafts (csn,o)
-  // Add a parsed _where clause for @restrict.{grant,where} annotations
-  if (csn.definitions) for (let {'@restrict':rr} of Object.values(csn.definitions)) if (rr) {
-    for (let r of rr) if (r.grant && r.where) try {
+  if ('_4java' in csn) return csn._4java
+  let dsn = csn // cds.minify (csn)
+  dsn = cds.compile.for.drafts (csn,o)
+  if (dsn.definitions) for (let [name,d] of Object.entries(dsn.definitions)) {
+    // Add @cds.external to external services
+    if (d.kind === 'service' && name in cds.requires) d['@cds.external'] = true
+    // Add parsed ._where clause to @restrict annotations
+    const rr = d['@restrict']
+    if (rr) for (let r of rr) if (r.grant && r.where) try {
       r._where = JSON.stringify (cds.parse.xpr(r.where))
     } catch(e){/* ignored */}
   }
-  return csn[_cached] = csn
-}
+  Object.defineProperty (csn, '_4java', {value:dsn})
+  Object.defineProperty (dsn, '_4java', {value:dsn})
+  return dsn
+}

package/lib/compile/for/nodejs.js

@@ -1,12 +1,12 @@
 const cds = require ('../../index')
-const _cached = Symbol('for Node.js')
 
 module.exports = function cds_compile_for_nodejs (csn,o) {
-  if (!csn) return
-  const cached = csn[_cached]; if (cached) return cached
-  // csn = cds.minify (csn)
-  csn = cds.compile.for.drafts (csn,o) //> creates a partial copy -> avoid any cds.linked() before
-  csn = cds.compile._localized.unfold_csn (csn)
-  csn = cds.linked (csn)
-  return csn[_cached] = csn
+  if ('_4nodejs' in csn) return csn._4nodejs
+  let dsn = csn // cds.minify (csn)
+  dsn = cds.compile.for.drafts (csn,o) //> creates a partial copy -> avoid any cds.linked() before
+  dsn = cds.compile._localized.unfold_csn (dsn)
+  dsn = cds.linked (dsn)
+  Object.defineProperty (csn, '_4nodejs', {value:dsn})
+  Object.defineProperty (dsn, '_4nodejs', {value:dsn})
+  return dsn
 }

package/lib/compile/for/odata.js

@@ -1,16 +1,11 @@
 const compile = require ('../cdsc')
 
 module.exports = function cds_compile_for_odata (csn,_o) {
-  if (_is_odata(csn))  return csn
-  let {_4odata} = csn; if (!_4odata) {
-    const o = compile._options.for.odata(_o) //> required to inspect .sql_mapping below
-    _4odata = compile.for.odata (csn,o)
-    // cache result for subsequent uses
-    Object.defineProperty (csn, '_4odata', { value: _4odata, configurable:1, writable:1 })
-    // compatibility with csn.json for old Java stack
-    if (o.sql_mapping) _4odata['@sql_mapping'] = o.sql_mapping
-  }
-  return _4odata
+  if ('_4odata' in csn) return csn._4odata
+  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
+  Object.defineProperty (csn, '_4odata', {value:dsn})
+  Object.defineProperty (dsn, '_4odata', {value:dsn})
+  return dsn
 }
-
-const _is_odata = csn => csn.meta && csn.meta.transformation === 'odata'

package/lib/compile/for/sql.js

@@ -1,10 +1,9 @@
-/** REVISIT: uses internal APIs to restore compile.for.sql in SNAPI */
-const compile = require ('@sap/cds-compiler/lib/backends')
+/** 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.toSqlWithCsn || compile.for_sql
-  // for_sql directly returns a CSN and not an object with a csn property
-  const res = _compile(src,{...o,csn:true})
-  return res.csn || res
+  _compile = _compile || compile.for_sql
+  // for_sql directly returns a CSN
+  return _compile(src,{...o,csn:true});
 }

package/lib/compile/index.js

@@ -20,6 +20,7 @@ const compile = module.exports = Object.assign (cds_compile, {
     csn: cds_compile,
     cdl: require('./to/cdl'),
     gql: require('./to/gql'),
+    graphql: require('./to/gql'),
     yml: require('./to/yaml'),
     yaml: require('./to/yaml'),
     json: require('./to/json'),
@@ -62,7 +63,7 @@ function cds_compile (model, options, _flavor) {
     // REVISIT: experimental implementation to detect external APIs
     for (let each in csn.definitions) {
       const d = csn.definitions[each]
-      if (d.kind === 'service' && cds.requires[each] && (!o.mocked || cds.requires[each].credentials)) {
+      if (d.kind === 'service' && cds.requires[each]?.external && (!o.mocked || cds.requires[each].credentials)) {
         Object.defineProperty (d,'@cds.external', { value: cds.requires[each].kind || true })
       }
     }
@@ -75,7 +76,7 @@ function cds_compile (model, options, _flavor) {
 
 const _is_csn = (x) => (x.definitions || x.extensions) && !x.$builtins
 const _is_files = m => {
-  if (Array.isArray(m) || /file:/.test(m) && (m = m.slice(5)))
+  if (Array.isArray(m) || /^file:/.test(m) && (m = m.slice(5)))
     return cds.resolve(m) || cds.error ( `Couldn't find a CDS model for '${m}' in ${cds.root}`,{ code:'MODEL_NOT_FOUND', model: m })
 }
 const _assert_flavor = (m,_flavor,options) => {
@@ -85,7 +86,7 @@ const _assert_flavor = (m,_flavor,options) => {
 
 const _flavors = {
   'parsed':   { level:1, cdsc_options: { parseCdl:true } },
-  'xtended':  { level:2, cdsc_options: { toCsn:{flavor:'gensrc'} } },
+  'xtended':  { level:2, cdsc_options: { csnFlavor:'gensrc' } },
   'inferred': { level:3 },
 }
 const _flavor4 = (o) => {
@@ -95,7 +96,7 @@ const _flavor4 = (o) => {
 const _options4 = (_o, _flavor) => {
   const flavor = _flavor ? _flavor4(_flavor) : _flavor4(_o) || 'inferred'
   const spec = _flavors[flavor]
-  const o = { ..._o, flavor, ...spec.cdsc_options, ...cds.env.cdsc }
+  const o = { ..._o, flavor, ...spec.cdsc_options, ...cds.env.cdsc, cdsHome: cds.home } // cdsHome is for the compiler resolving @sap/cds/... files
   if (o.docs) o.docComment = true
   if (o.locations) o.withLocations = true
   if (!o.messages) o.messages = []

package/lib/compile/load.js

@@ -1,16 +1,17 @@
 const cds = require('..')
 
 
-function cds_load (files, options) {
+module.exports = exports = function cds_load (files, options) {
   const all = cds.resolve(files,options)
-  if (!all)  return cds.error.reject (
-    `Couldn't find a CDS model for '${files}' in ${cds.root}`, { code:'MODEL_NOT_FOUND', files }
-  )
+  if (!all)  return Promise.reject (new cds.error ({
+    message: `Couldn't find a CDS model for '${files}' in ${cds.root}`,
+    code: 'MODEL_NOT_FOUND', files,
+  }))
   return this.get (all,options,'inferred')
 }
 
 
-function cds_get (files, options, _flavor) { // NOSONAR
+exports.parsed = function cds_get (files, options, _flavor) { // NOSONAR
 
   const o = typeof options === 'string' ? { flavor:options } : options || {}
   if (!files) files = ['*']; else if (!Array.isArray(files)) files = [files]
@@ -39,9 +40,6 @@ const _sources4 = async (files) => {
   return files.reduce ((all,f,i) => { all[relative(cwd,f)] = sources[i]; return all },{})
 }
 
-module.exports = Object.assign (cds_load, {
-  parsed: cds_get,
-  properties: (...args) => (cds_load.properties = require('./etc/properties').read) (...args),
-  yaml: (file) => (cds_load.yaml = require('./etc/yaml').read) (file),
-  csv: (file) => (cds_load.csv = require('./etc/csv').read) (file),
-})
+exports.properties = (...args) => (exports.properties = require('./etc/properties').read) (...args)
+exports.yaml = (file) => (exports.yaml = require('./etc/yaml').read) (file)
+exports.csv = (file) => (exports.csv = require('./etc/csv').read) (file)

package/lib/compile/minify.js

@@ -1,11 +1,14 @@
-module.exports = function cds_minify (csn, _roots = global.cds.env.features.skip_unused) {
-  if (_roots === false) return csn
+const cds = require('../index')
+
+module.exports = function cds_minify (csn, _roots) { // IMPORTANT: don't add cds.env.features.skip_unused as default for _roots here, as that will break VSCode's IntelliSense
+  const roots = _roots !== undefined ? _roots : cds.env.features.skip_unused
+  if (roots === false) return csn
   if (csn[_minified]) return csn; else Object.defineProperty (csn,_minified,{value:true})
   const all = csn.definitions, reached = new Set
-  if (_roots === 'services') {
+  if (roots === 'services') {
     for (let n in all) if (all[n].kind === 'service') _visit_service(n)
-  } else if (typeof _roots === 'string') {
-    _visit_service(_roots)
+  } else if (typeof roots === 'string') {
+    _visit_service(roots)
   } else for (let n in all) {
     let d = all[n]
     if (d.kind === 'service') _visit_service(n)

package/lib/compile/parse.js

@@ -28,10 +28,10 @@ const parse = module.exports = Object.assign (cds_parse, {
     }
     else return parse.expr(x)
   },
-  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:[]}) } catch(e) {
+    try { return cdsc.parse.expr(x,undefined,{ messages:[], ...o }) } catch(e) {
       e.message = e.message.replace('<expr>.cds:1:',`In '${e.expr = x}' at `)
       throw e // with improved error message
     }
@@ -49,6 +49,7 @@ const parse = module.exports = Object.assign (cds_parse, {
 
 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]
@@ -64,6 +65,7 @@ const tagged = (parse, strings, ...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)

package/lib/compile/resolve.js

@@ -25,7 +25,7 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
   if (model.endsWith('/*')) return _resolve_subdirs_in(model,o,this)
 
   const cwd = o.root || this.root, local = resolve (cwd,model)
-  const context = _paths(cwd), {cached} = context
+  const context = _paths(cwd,o), {cached} = context
   let id = model.startsWith('.') ? local : model
   if (id in cached)  return cached[id]
 
@@ -65,37 +65,40 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
 exports.cache = {}
 
 
-const _required = cds => Object.values(cds.env.requires) .map (r => r.model) .filter(x=>x)
+const _required = (cds,env=cds.env) => Object.values(env.requires) .map (r => r.model) .filter(x=>x)
 const _resolve = require('module')._resolveFilename
 
 function _resolve_all (o,cds) {
-  const {roots} = cds.env; if (o.dry || o === false)  return [ ...roots, ..._required(cds) ]
-  const cached = exports.cache['*']; if (cached) return cached
-  exports.cache['*'] = [] // important to avoid endless recursion on '*'
+  const {roots} = o.env || cds.env; if (o.dry || o === false)  return [ ...roots, ..._required(cds) ]
+  const cache = o.cache || exports.cache
+  const cached = cache['*']; if (cached) return cached
+  cache['*'] = [] // important to avoid endless recursion on '*'
   const sources = cds.resolve (roots,o) || []
   if (!(sources.length === 1 && sources[0].endsWith('csn.json'))) // REVISIT: why is that? -> pre-compiled gen/csn.json?
-    sources.push (...cds.resolve (_required(cds),o)||[])
-  return exports.cache['*'] = _resolved (sources)
+    sources.push (...cds.resolve (_required(cds,o.env),o)||[])
+  return cache['*'] = _resolved (sources)
 }
 
 function _resolve_subdirs_in (pattern='fts/*',o,cds) {
-  const cached = exports.cache[pattern]; if (cached && !o.dry && o !== false)  return cached
-  const folder = pattern.slice(0,-2), dir = resolve (cds.root, folder)
+  const cache = o.cache || exports.cache
+  const cached = cache[pattern]; if (cached && !o.dry && o !== false)  return cached
+  const folder = pattern.slice(0,-2), dir = resolve (o.root || cds.root, folder)
   try {
-    const dirs = readdirSync(dir) .map (e => folder+'/'+e+'/') .filter (cds.utils.isdir)
+    const dirs = readdirSync(dir) .filter (e => cds.utils.isdir(dir+sep+e)) .map (e => folder+sep+e+sep)
     if (o.dry || o === false)  return dirs
-    return exports.cache[pattern] = cds.resolve (dirs,o) || undefined
+    return cache[pattern] = cds.resolve (dirs,o) || undefined
   } catch(e) {
     if (e.code === 'ENOENT')
-    return exports.cache[pattern] = undefined
+    return cache[pattern] = undefined
   }
 }
 
-function _paths (dir) {
-  const cached = exports.cache[dir]; if (cached)  return cached
+function _paths (dir,o) {
+  const cache = o.cache || exports.cache
+  const cached = cache[dir]; if (cached)  return cached
   const a = dir.split(sep), n = a.length, nm = sep+'node_modules'
   const paths = [ dir, ...a.map ((_,i,a)=> a.slice(0,n-i).join(sep)+nm) ]
-  return exports.cache[dir] = { paths, cached:{} }
+  return cache[dir] = { paths, cached:{} }
 }
 
 function _resolved (array) {

package/lib/compile/to/edm.js

@@ -55,5 +55,4 @@ function* _many (suffix, all, callback = x=>x) {
   for (let file in all) yield [ callback(all[file]), { file, suffix } ]
 }
 
-
 module.exports = Object.assign (cds_compile_to_edm, { x: cds_compile_to_edmx })

package/lib/compile/to/gql.js

@@ -1,9 +1,10 @@
-const { generate } = require ('../../../libx/gql/schema')
 const cds = require ('../..')
+const { SchemaGenerator } = require('@sap/cds-graphql/lib/schema')
 
 function cds_compile_to_gql (csn) {
   const m = cds.linked(csn)
-  return generate (m.services.map(s => ({ name:s.name, model:m })))
+  const services = Object.fromEntries(m.services.map(s => [s.name, new cds.ApplicationService(s.name, m)]))
+  return new SchemaGenerator().generate(services).printSchema()
 }
 
 module.exports = cds_compile_to_gql

package/lib/compile/to/json.js

@@ -1,25 +1,32 @@
 const cds = require ('../../index')
-
 const path = require('path')
 
-module.exports = (csn,o={}) => JSON.stringify (csn, (_,v) => {
+module.exports = (csn,o={}) => {
+  const relative = filename => (o.src !== o.cwd) ? path.relative(o.src, path.join(o.cwd, filename)) : filename
+  const relative_cds_home = RegExp ('^' + path.relative (o.src || o.cwd || cds.root, cds.home) + '/')
+  const resolver = (_,v) => {
 
-  if (!v) return v
+    if (!v) return v
 
-  else if (v.grant && v.where) try {
-    // Add a parsed _where clause for @restrict.{grant,where} annotations
-    // Note: This has moved to cds.compile.for.java meanwhile, but is kept
-    // here for compatibility, at least temporarily.
-    return {...v, _where: JSON.stringify (cds.parse.xpr(v.where)) }
-  } catch(e){/* ignored */}
+    else if (v.grant && v.where) try {
+      // Add a parsed _where clause for @restrict.{grant,where} annotations
+      // Note: This has moved to cds.compile.for.java meanwhile, but is kept
+      // here for compatibility, at least temporarily.
+      return {...v, _where: JSON.stringify (cds.parse.xpr(v.where)) }
+    } catch(e){/* ignored */}
 
-  else if (v.kind === "service" && !v['@source'] && v.$location && v.$location.file) {
-    // Preserve original sources for services so we can use them for finding
-    // sibling implementation files when reloaded from csn.json.
-    const file = (o.cwd !== o.src) ? path.relative(o.src, path.join(o.cwd, v.$location.file)) : v.$location.file
-    return { '@source': file.replace(/\\/g,'/'), ...v }
-  }
+    else if (v.kind === "service" && !v['@source'] && v.$location?.file) {
+      // Preserve original sources for services so we can use them for finding
+      // sibling implementation files when reloaded from csn.json.
+      const file = relative(v.$location.file)
+      .replace(relative_cds_home,'@sap/cds/')
+      .replace('node_modules/','')
+      .replace(/\\/g,'/')
+      return { '@source': file, ...v }
+    }
 
-  return v
+    return v
 
-}, o && o.indents || 2)
+  }
+  return JSON.stringify (csn, resolver, o && o.indents || 2)
+}

package/lib/connect/bindings.js

@@ -41,7 +41,8 @@ module.exports = class Bindings {
         const required = cds.requires; if (!required) return this
         const provided = (await this.load()) .cds.provides
         for (let each in required) {
-            const req = required[each], bound = provided [req.service||each]
+            const req = required[each]; if (typeof req !== 'object') continue
+            const bound = provided [req.service||each]
             if (bound) {
               Object.assign (req.credentials || (req.credentials = {}), bound.credentials)
               // REVISIT: temporary fix to inherit kind as well for mocked odata services
@@ -67,7 +68,7 @@ module.exports = class Bindings {
                 }
             }
         }
-        process.on ('exit', ()=>this.purge())
+        cds.on ('shutdown', ()=>this.purge())
         return this.store()
     }
 

package/lib/connect/index.js

@@ -28,9 +28,9 @@ connect.to = async (datasource, options) => {
     if (!options) { //> specifying ad-hoc options disallows caching
       if (datasource in cds.services) return cds.services[datasource]
       if (datasource in _pending) return _pending[datasource]
+      // queue parallel requests to a single promise, to avoid creating multiple services
+      _pending[datasource] = new Promise (r=>_done=r).finally(()=> delete _pending[datasource])
     }
-    // queue parallel requests to a single promise, to avoid creating multiple services
-    _pending[datasource] = new Promise (r=>_done=r).finally(()=>{ delete _pending[datasource] })
   }
   const o = Service === cds.service.factory ? options4 (datasource, options) : {}
   const m = await model4 (o)
@@ -41,7 +41,7 @@ connect.to = async (datasource, options) => {
     throw new Error (`No service definition found for '${required.service || datasource}'`)
   }
   // construct new service instance
-  const srv = new Service (datasource,m,o)
+  const srv = await new Service (datasource,m,o)
   await srv.prepend (srv.init, srv.options.impl)
   if (datasource === 'db') cds.db = srv
   _done (cds.services[datasource] = srv)
@@ -51,11 +51,11 @@ connect.to = async (datasource, options) => {
 
 function options4 (name, _o) {
   const [, kind=_o && _o.kind, url] = /^(\w+):(.*)/.exec(name) || []
-  const conf = cds.requires[name] || cds.requires[kind]
+  const conf = cds.requires[name] || cds.requires[kind] || cds.requires.kinds[name] || cds.requires.kinds[kind]
   const o = { kind, ...conf, ..._o }
   if (!o.kind && !o.impl && !o.silent) throw cds.error(
     conf ? `Configuration for 'cds.requires.${name}' lacks mandatory property 'kind' or 'impl'` :
-      name ? `Didn't find a configuration for 'cds.requires.${name}'` :
+      name ? `Didn't find a configuration for 'cds.requires.${name}' in ${cds.root}` :
         `Provided options object lacks mandatory property 'kind' or 'impl'`
   )
   if (url) o.credentials = { ...o.credentials, url }

package/lib/core/classes.js

@@ -9,15 +9,20 @@ class any {
   is (kind) { return this.kind === kind || kind === 'any' }
   valueOf() { return this.name }
 
-  own (property) {
+  own (property, ifAbsent) {
     const pd = Reflect.getOwnPropertyDescriptor (this, property)
     if (pd) return pd.value //|| pd.get(this)
+    if (ifAbsent) return this.set (property, ifAbsent())
   }
 
   set (property, value, enumerable = false) {
     Reflect.defineProperty (this, property, { value, enumerable, writable:1, configurable:1 })
     return value
   }
+
+  dataIn (d, prefix='') {
+    return d[prefix + this.name]
+  }
 }
 
 class type extends any {}
@@ -47,9 +52,76 @@ class service extends context {
 
 class array extends type { is(kind) { return kind === 'array' || super.is(kind) }}
 class aspect extends type { is(kind) { return kind === 'aspect' || super.is(kind) }}
-class struct extends aspect { is(kind) { return kind === 'struct' || super.is(kind) }}
 class event extends aspect{}
 
+class struct extends aspect {
+  is(kind) { return kind === 'struct' || super.is(kind) }
+
+  /**
+   * Gets the foreign key data for a given managed association from inbound data
+   * in structured form.
+   *
+   * @example
+   * let { Books } = srv.entities
+   * let { author } = Books.elements
+   * let book = { // inbound data, e.g. from req.data
+   *   title: 'Foo',
+   *   author_ID: 111
+   * }
+   * let value = author.dataIn(book)
+   * //> { ID: 111 }
+   *
+   * Actually this works for all struct-like elements, i.e., which's definitions
+   * have .elements or .foreignKeys. Could be added to cds.struct/cds.Association.
+   */
+  dataIn (d, prefix='', _skip_root) {
+    const key = prefix + this.name; if (!_skip_root && key in d) return d[key]
+    const elements = this.elements || this.foreignKeys // REVISIT: .foreignKeys should be .elements
+    const nested={}, key_ = _skip_root ? '' : key+'_'
+    let any; for (let e in elements) {
+      const v = elements[e] .dataIn (d,key_)
+      if (v !== undefined) nested[any=e] = v
+    }
+    if (any) return !prefix && d._hull ? d._hull[key] = nested : nested
+  }
+
+  /**
+   * Returns a Proxy for provided data which adds getters to return values
+   * for struct elements (including Associations) in structured form.
+   *
+   * @example
+   * let { Books } = m.entities
+   * let data = Books.data ({
+   *   author: {ID:111},
+   *   genre_ID: 22
+   * })
+   * console.log ('author:', data.author) //> { ID: 111 }
+   * console.log ('genre:', data.genre)  //> { ID: 22 }
+   */
+   data (d) {
+    if (_proxy in d) return d[_proxy] //> use cached proxy, if exists
+
+    // hull to cache calculated values without polluting original input
+    const _hull = {__proto__:d}
+
+    // allow external code to access _hull
+    Object.defineProperty (_hull, '_hull', {value:_hull})
+
+    // proxy calls def.dataIn() for defined elements, fallback hull[p]
+    const {elements} = this, proxy = new Proxy (d, {
+      get: (_,p) => elements[p]?.dataIn(_hull) || _hull[p],
+    })
+
+    // cache proxy with original data
+    Object.defineProperty (d, _proxy, {value:proxy})
+
+    return proxy
+  }
+
+}
+const _proxy = Symbol('_proxy')
+
+
 /**
  * Export is a dictionary of all builtin classes
  */

package/lib/core/entities.js

@@ -1,4 +1,4 @@
-const { struct, type } = require ('./classes')
+const { struct } = require ('./classes')
 
 class entity extends struct   {
   is (kind) { return kind === 'entity' || kind === 'view' && !!this.query || super.is(kind) }
@@ -23,7 +23,8 @@ class entity extends struct   {
   }
 }
 
-class Association extends type {
+
+class Association extends struct {
 
   is(kind) { return kind === 'Association' || super.is(kind) }
   get isAssociation(){ return true }
@@ -41,7 +42,7 @@ class Association extends type {
     for (const k of keys) {
       const el = k.ref.reduce((target,n)=> target.elements[n], this._target)
       const as = k.as || k.ref[k.ref.length-1]
-      foreignKeys [as] = el
+      foreignKeys [as] = el.name === as ? el : { __proto__:el, name:as }
     }
     return this.foreignKeys = foreignKeys
   }
@@ -53,7 +54,55 @@ class Association extends type {
     for (let k in tks) keys.push({ ref: [tks[k].name] })
     return this.keys = keys
   }
+
+  /**
+   * Gets the foreign key data for a given managed association from inbound data
+   * converted to an object that can be used as a where clause filter to fetch
+   * from the assoc's target entity. The function correctly handles renamed
+   * foreign keys.
+   *
+   * @example
+   * entity Books { //...
+   *   author : Association to Authors { ID:id } // renamed foreign key
+   * }
+   *
+   * @example
+   * let { Books, Authors } = srv.entities
+   * let { author } = Books.elements
+   * let data = { // inbound data, e.g. from req.data
+   *   title: 'Foo',
+   *   author_id: 111
+   * }
+   * let entry = author.refIn(data)
+   * //> { ref: [ {id:'Authors', where:[ {ref:['ID']}, '=', {val:111} ]} ]}
+   * await SELECT.one(entry)
+   * await db.exists(entry)
+   */
+  refIn (d) {
+    if (!this.keys) throw new Error (`Can't collect filter data for unmanaged associations`)
+    const value = this.dataIn(d); if (!value) return
+    const where={}; for (let {ref:[r],as} of this.keys) where[r] = value[as||r]
+    const q = SELECT.from (this._target, where)
+    return q.SELECT.from
+  }
+
+  /**
+   * Overriding implementation in base class to handle data for to-many Associations.
+   */
+  dataIn (d, prefix='') {
+    if (this.is2many) {
+      const key = this.name, _key = '_'+key; if (_key in d) return d[_key]
+      const input = d[key]; if (input[_is_cached]) return input
+      if (Array.isArray(input)) {
+        const value = d[key].map (each => this._target.dataIn (each,'',true))
+        if (!prefix && d._hull) d._hull[key] = Object.defineProperty(value, _is_cached, {value:true})
+        return value
+      }
+    }
+    else return super.dataIn (d,prefix)
+  }
 }
+const _is_cached = Symbol('_cached')
 
 
 class Composition extends Association {

package/lib/core/reflect.js

@@ -25,6 +25,7 @@ class LinkedCSN extends any {
         /* else: */         any.prototype
       )
       if (p.key && !d.key && d.kind === 'element') Object.defineProperty (d,'key',{value:undefined})  //> don't propagate .key
+      if (p.params && !d.params && d.kind === 'entity') Object.defineProperty (d,'params',{value:undefined})  //> don't propagate .key
       if (d.elements && d.elements.localized) Object.defineProperty (d,'texts',{value: defs [d.elements.localized.target] })
       try { return Object.setPrototypeOf(d,p) }            //> link d to resolved proto
       catch(e) {                                          //> cyclic proto error
@@ -108,5 +109,5 @@ const _is = x => {
 
 /** @returns {LinkedCSN} */
 module.exports = x => x instanceof any ? x : new LinkedCSN (
-  typeof x === 'string' ? global.cds.parse(x) : x
+  typeof x === 'string' ? require('../index').compile(x) : x
 )