@sap/cds 5.8.2 → 5.9.0

package/lib/compile/index.js

@@ -9,6 +9,9 @@ const {lazified} = require ('../lazy'); require = lazified (module)  // eslint-d
 const compile = module.exports = Object.assign (cds_compile, {
 
   for: lazified ({
+    java: require('./for/java'),
+    nodejs: require('./for/nodejs'),
+    drafts: require('./for/drafts'),
     odata: require('./for/odata'),
     sql: require('./for/sql'),
   }),

package/lib/compile/minify.js

@@ -32,11 +32,11 @@ module.exports = function cds_minify (csn, _roots = global.cds.env.features.skip
   }
   function _visit (d) {
     if (typeof d === 'string') {
-      if (d.startsWith('cds.')) return
+      if (isInReservedNamespace(d)) return
       else d = all[d]
     } else if (d.ref) return d.ref.reduce((p,n) => {
       let d = (p.elements || csn.definitions[p.target].elements)[n.id || n] // > n.id -> view with parameters
-      _visit(d)
+      if (d)  _visit(d)
       return d
     },{elements:all})
     if (reached.has(d)) return; else reached.add(d)
@@ -58,4 +58,18 @@ module.exports = function cds_minify (csn, _roots = global.cds.env.features.skip
   return minified
 }
 
+/**
+ * TODO - keep in sync with @sap/cds-compiler. Use their public API once it is available!
+ * Checks whether the given absolute path is inside a reserved namespace.
+ *
+ * @param {string} absolute
+ * @returns {boolean}
+ */
+function isInReservedNamespace(absolute) {
+  return absolute.startsWith( 'cds.') &&
+    !absolute.match(/^cds\.foundation(\.|$)/) &&
+    !absolute.match(/^cds\.outbox(\.|$)/) && // Requested by Node runtime
+    !absolute.match(/^cds\.xt(\.|$)/); // Requested by Mtx
+}
+
 const _minified = Symbol('minified')

package/lib/compile/parse.js

@@ -10,7 +10,7 @@ const parse = module.exports = Object.assign (cds_parse, {
   CXL: (...args) => tagged(parse.expr, ...args),
 
   cdl: cds_parse,
-  cql: x => { try { return cdsc.parse.cql(x,undefined,{messages:[]}) } catch(e) {
+  cql: (x,o) => { try { return cdsc.parse.cql(x,undefined,{ messages:[],  ...o }) } catch(e) {
     e.message = e.message.replace('<query>.cds:',`In '${e.cql = x}' at `)
     throw e // with improved error message
   }},
@@ -76,4 +76,4 @@ const merge = (o,values) => {
 }
 
 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 }
+const keywords = { KEY:1, key:1, SELECT:1, select:1 }

package/lib/compile/resolve.js

@@ -2,6 +2,7 @@ const { resolve, join, sep } = require('path')
 const { readdirSync } = require('fs')
 const suffixes = [ '.csn', '.cds', sep+'index.csn', sep+'index.cds', sep+'csn.json' ]
 
+
 /**
 * Resolves given model references to an array of absolute filenames.
 * For the model references, all these are accepted:
@@ -16,18 +17,20 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
 
   if (!model || model === '--') return
   if (model._resolved) return model
-  if (model === '*') return exports.cache['*'] || _resolve_all(this,o)
-  if (Array.isArray(model)) return _resolved (
-    [... new Set(model)] .reduce ((prev,next) => prev.concat (this.resolve(next,o)||[]), [])
-  )
+  if (model === '*') return _resolve_all(o,this)
+  if (Array.isArray(model)) {
+    const resolved = [... new Set(model)] .reduce ((prev,next) => prev.concat (this.resolve(next,o)||[]), [])
+    return o.dry || o === false ? resolved : _resolved (resolved)
+  }
+  if (model.endsWith('/*')) return _resolve_subdirs_in(model,o,this)
 
-  const cwd = o.root || global.cds && global.cds.root, local = resolve (cwd,model)
+  const cwd = o.root || this.root, local = resolve (cwd,model)
   const context = _paths(cwd), {cached} = context
   let id = model.startsWith('.') ? local : model
-  if (id in cached && !o.skipModelCache)  return cached[id]
+  if (id in cached)  return cached[id]
 
   // expand @sap/cds by cds.home
-  if (id.startsWith('@sap/cds/')) id = global.cds.home + id.slice(8)
+  if (id.startsWith('@sap/cds/')) id = this.home + id.slice(8)
 
   // fetch file with .cds/.csn suffix as is
   if (/\.(csn|cds)$/.test(id)) try {
@@ -58,27 +61,41 @@ 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 _resolve = require('module')._resolveFilename
 
-function _resolve_all (cds,o) {
-  const {roots,requires} = cds.env, {cache} = exports
-  const required = Object.values(requires) .map (r => r.model) .filter(x=>x)
-  if (o.dry || o === false)  return [ ...roots, ...required ]
-  cache['*'] = [] // important to avoid endless recursion on '*'
-  const resolved = cds.resolve (roots,o) || []
-  if (!(resolved.length === 1 && resolved[0].endsWith('csn.json')))
-  resolved.push (...cds.resolve (required,o)||[])
-  return cache['*'] = _resolved ([ ...new Set (resolved) ])
+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 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)
+}
+
+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)
+  try {
+    const dirs = readdirSync(dir) .map (e => folder+'/'+e+'/') .filter (cds.utils.isdir)
+    if (o.dry || o === false)  return dirs
+    return exports.cache[pattern] = cds.resolve (dirs,o) || undefined
+  } catch(e) {
+    if (e.code === 'ENOENT')
+    return exports.cache[pattern] = undefined
+  }
 }
 
 function _paths (dir) {
-  const {cache} = exports; if (dir in cache)  return cache[dir]
+  const cached = exports.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 cache[dir] = { paths, cached:{} }
+  return exports.cache[dir] = { paths, cached:{} }
 }
 
 function _resolved (array) {

package/lib/compile/to/json.js

@@ -8,12 +8,14 @@ module.exports = (csn,o={}) => JSON.stringify (csn, (_,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.kind === "service" && !v['@source'] && v.$location && v.$location.file) {
     // Preserve original sources for services so we can use them for finding
-    // sibling implementation filed when reloaded from csn.json.
+    // 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 }
   }

package/lib/compile/to/sql.js

@@ -1,4 +1,4 @@
-const cds = require ('../..'), { unfold_ddl: cds_localized } = cds.compile._localized
+const cds = require ('../..')
 const cdsc = require ('../cdsc')
 
 
@@ -6,7 +6,7 @@ function cds_compile_to_sql (csn,_o) {
   csn = _extended(cds.minify(csn))
   const o = cdsc._options.for.sql(_o) //> used twice below...
   const all = cdsc.to.sql(csn,o) .map (each => each.replace(/^-- .+\n/,''))  //> strip comments
-  const sql = cds_localized(all, csn, o)
+  const sql = cds.compile._localized.unfold_ddl(all, csn, o)
   if (o.as === 'str') return `\n${sql.join('\n\n')}\n`
   return sql
 }

package/lib/compile/to/srvinfo.js

@@ -74,8 +74,10 @@ module.exports = (model, options={}) => {
       if (file) {
         const yaml = cds.load.yaml(file)
         for (let {cds} of Array.isArray(yaml) ? yaml : [yaml]) {
-          if (cds && cds['odata-v4.endpoint.path'])  return cds['odata-v4.endpoint.path']
-          if (cds && cds['odata-v2.endpoint.path'])  return cds['odata-v2.endpoint.path']
+          if (!cds)   continue
+          return cds['odataV4.endpoint.path']  || cds['odataV2.endpoint.path'] // https://cap.cloud.sap/docs/java/application-services#configure-base-path
+              || cds['odata-v4.endpoint.path'] || cds['odata-v2.endpoint.path'] // older/intermediate config, keep for backward compatibility
+
         }
         return 'odata/v4/'
       }

package/lib/connect/index.js

@@ -38,7 +38,7 @@ connect.to = async (datasource, options) => {
   // check if required service definition exists
   const required = cds.requires[datasource]
   if (required && required.model && datasource !== 'db' && !m.definitions[required.service||datasource]) {
-    LOG._error && LOG.error(`No service definition found for '${required.service || datasource}', as required by 'cds.requires.${datasource}':`, required)
+    LOG.error(`No service definition found for '${required.service || datasource}', as required by 'cds.requires.${datasource}':`, required)
     throw new Error (`No service definition found for '${required.service || datasource}'`)
   }
   // construct new service instance

package/lib/core/entities.js

@@ -34,23 +34,24 @@ class Association extends type {
     return !c || c.max === 1 || (!c.max && !c.targetMax) || c.targetMax === 1
   }
 
-  set _elements(k) { this.set('_elements', k) }
-  get _elements() {
-    const { keys } = this
-    if (!keys) return (this._elements = undefined)
-    const fks = {},{ elements } = this._target
-    for (let k of keys) fks[k.as || k.ref[0]] = elements[k.ref[0]]
-    return (this._elements = fks)
+  set foreignKeys(k) { this.set('foreignKeys', k) }
+  get foreignKeys() {
+    const keys = this.keys; if (!keys) return this.foreignKeys = undefined
+    const foreignKeys = {}
+    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
+    }
+    return this.foreignKeys = foreignKeys
   }
 
-  set _keys(k) { this.set('keys', k) }
-  get _keys() {
-    if (this.keys) return (this._keys = this.keys)
-    if (this.on || this.is2many || !this._target) return (this._keys = undefined)
-    const keys = [],
-      tks = this._target.keys
+  set keys(k) { super.keys = k }
+  get keys() {
+    if (this.on || this.is2many || !this._target) return this._keys = undefined
+    const keys=[], tks = this._target.keys
     for (let k in tks) keys.push({ ref: [tks[k].name] })
-    return (this._keys = keys)
+    return this.keys = keys
   }
 }
 

package/lib/core/index.js

@@ -8,8 +8,9 @@ const classes = Object.assign (
 	require('./entities'),
 )
 
-// Type system roots -> can be used with instanceof
-const roots = _bootstrap ({
+
+/** Type system roots -> can be used with instanceof */
+const roots = _roots ({
 	context: {},
 	type: {},
 		scalar: {type:'type'},
@@ -27,9 +28,28 @@ const roots = _bootstrap ({
 	service: {type:'context'},
 })
 
-// Adding common recommended types
-const common = { __proto__:roots,
-	UUID: {type:'string',length:36},
+/**
+ * Turns the given CSN definitions into linked definitions with classes.
+ * @type <T>(csn:T) => T
+ */
+ function _roots (defs) {
+	const linked = { any: classes.any.prototype }
+	for (const t in defs) {
+		if (t in classes) {
+			linked[t] = classes[t].prototype
+			continue
+		}
+		const c = class extends classes[defs[t].type || 'any'] {}
+		linked[t] = Object.defineProperty (c.prototype, 'name', {value:t})
+		classes[t] = Object.defineProperty (c, 'name', {value:t})
+	}
+	return linked
+}
+
+
+/** Construct builtin.types as dictionary of all roots and common types */
+const types = _common ({ __proto__: roots,
+	UUID: {type:'string',length:36,isUUID:true},
 	Boolean: {type:'boolean'},
 	Integer: {type:'number'},
 		Integer16: {type:'Integer'},
@@ -47,41 +67,24 @@ const common = { __proto__:roots,
 	Binary: {type:'string'},
 	LargeString: {type:'string'},
 	LargeBinary: {type:'string'},
-}
+})
 
 /**
- * Construct builtin.types as dictionary of all roots and common types
- * @type { typeof roots & typeof common }
+ * Link all definitions, essentially by: d.__proto__ = resolved (d.type),
+ * and prefixes all common types with a namespace 'cds'.
+ * @type <T>(csn:T) => T & roots
  */
-const types = { __proto__:common }
-
-// Link all definitions, essentially by: d.__proto__ = resolved (d.type)
-for (let [name,d] of Object.entries(common)) {
-	common[name] = Object.defineProperty({ ...d, __proto__: types[d.type] }, 'name', {value:name})
+function _common (defs) {
+	const prefixed = {__proto__:defs}
+	for (let [name,d] of Object.entries(defs)) {
+		defs[name] = Object.defineProperty({ ...d, __proto__: defs[d.type] }, 'name', {value:name})
+		Object.defineProperty (prefixed['cds.'+name] = defs[name], '_type', {value:'cds.'+name})
+	}
+	for (let name of ['Association','Composition']) {
+		Object.defineProperty (prefixed['cds.'+name] = defs[name], '_type', {value:'cds.'+name})
+	}
+	return prefixed
 }
 
-// Prefix all common types with a namespace 'cds'
-for (let t of Object.keys(common))  types['cds.'+t] = types[t]
-types['cds.Association'] = types.Association
-types['cds.Composition'] = types.Composition
 
 module.exports = { types, classes }
-
-
-/**
- * Turns the given CSN definitions into linked definitions.
- * @type <T>(csn:T) => T
- */
-function _bootstrap (csn) {
-	const defs = { any: classes.any.prototype }
-	for (const t in csn) {
-		if (t in classes) {
-			defs[t] = classes[t].prototype
-			continue
-		}
-		const c = class extends classes[csn[t].type || 'any'] {}
-		defs[t] = Object.defineProperty(c.prototype, 'name', { value: t })
-		classes[t] = Object.defineProperty(c, 'name', { value: t })
-	}
-	return defs
-}

package/lib/core/reflect.js

@@ -95,7 +95,7 @@ class LinkedCSN extends any {
 }
 
 
-const _unresolved = (x,unknown=any) => ({name:x, __proto__:unknown.prototype, _unresolved:true})
+const _unresolved = (x,unknown=any) => ({ name:x, __proto__:unknown.prototype, _unresolved:true })
 const _builtin = x => types[x] || typeof x === 'string' && x.startsWith('cds.hana.') && any.prototype
 const _infer = require('./infer'), _not_inferred = _unresolved('<query>',entity)
 const _set = (o,p,v) => Object.defineProperty (o,p,{value:v,enumerable:false,configurable:1,writable:1})
@@ -107,4 +107,6 @@ const _is = x => {
 }
 
 /** @returns {LinkedCSN} */
-module.exports = x => x instanceof any ? x : new LinkedCSN(x)
+module.exports = x => x instanceof any ? x : new LinkedCSN (
+  typeof x === 'string' ? global.cds.parse(x) : x
+)