@sap/cds 5.8.2 → 5.9.0

package/lib/env/index.js

@@ -1,9 +1,8 @@
-const { isfile, fs } = require('../utils')
+const { isfile, fs, path } = require('../utils')
 const DEFAULTS = require('./defaults'), defaults = require.resolve ('./defaults')
-const os_user_home = require('os').homedir()
 const compat = require('./compat')
 const presets = require('./presets')
-const path = require('path')
+
 
 /**
  * Both a config inctance as well as factory for.
@@ -27,7 +26,13 @@ class Config {
    */
   constructor (_context, _home, _defaults=true) {
     Object.assign (this, { _context, _home, _sources:[] })
-    this._profiles = _determineProfilesFrom (process.env)
+
+    // 0. determine profiles from NODE_ENV+ CDS_ENV
+    const { NODE_ENV, CDS_ENV } = process.env, profiles = []
+    if (NODE_ENV) profiles.push (NODE_ENV)
+    if (CDS_ENV) profiles.push (...CDS_ENV.split(/\s*,\s*/))
+    if (!profiles.includes('production')) profiles.push('development')
+    this._profiles = new Set (profiles)
     this._profiles._defined = new Set()
 
     // 1. set compat requires default values
@@ -39,7 +44,7 @@ class Config {
     this._add_to_process_env (_home, 'default-env.json')
 
     // additional env for dev => 4.
-    if (process.env.NODE_ENV !== 'production') {
+    if (!this._profiles.has('production')) {
       this._add_to_process_env (_home, '.env')
     }
 
@@ -51,10 +56,10 @@ class Config {
     }
 
     // 3. read important (!) profiles from config sources in defined order
-    const overwriteProfiles = new Set(this.profiles.map( profile => `${profile}!` ).filter( profile => this._profiles._defined.has( profile ) ));
-    if (overwriteProfiles.size > 0) {
+    const important = new Set(this.profiles.map( profile => `${profile}!` ).filter( profile => this._profiles._defined.has( profile ) ));
+    if (important.size > 0) {
       for (const source of sources) {
-        this._load(source.path, source.file, source.mapper, overwriteProfiles, true)
+        this._load(source.path, source.file, source.mapper, important, true)
       }
     }
 
@@ -63,6 +68,7 @@ class Config {
 
     // 6. link dependant services (through kind/use)
     this._link_required_services()
+
     // 7. complete service configurations from VCAP
     this._add_vcap_services (process.env.VCAP_SERVICES)
 
@@ -78,7 +84,9 @@ class Config {
     presets (this)
 
     // Only if feature is enabled
-    this._emulate_vcap_services()
+    if (this.features && this.features.emulate_vcap_services) {
+      this._emulate_vcap_services()
+    }
   }
 
   /**
@@ -87,9 +95,9 @@ class Config {
    * @param {string} home Project home
    * @param {string} context configuration context literal
    */
-  static sources(home, context = 'cds', ) {
+  static sources (home, context = 'cds') {
     if (!home) throw new Error('Missing parameter "home".')
-    const user_home = process.env.CDS_USER_HOME || os_user_home
+    const user_home = process.env.CDS_USER_HOME || require('os').homedir()
 
     let sources = [
       { name: 'USER_HOME', path: user_home, file: '.cdsrc.json' },
@@ -102,6 +110,22 @@ class Config {
     return sources
   }
 
+
+  add (conf, /*from:*/ _src, profiles = this._profiles, profiles_only = false) {
+    if (!conf)  return this
+    if (_src)  this._sources.push (_src)
+    _merge (this, conf, profiles, undefined, profiles_only)
+    return this
+  }
+
+  /**
+   * Retrieves the value for a config option, specified as a property path.
+   */
+  get (option) {
+    if (!option)  return
+    return option.split('.').reduce ((p,n)=> p && p[n], this)
+  }
+
   /**
    * This is `this.requires` plus additional entries for all cds.required.<name>.service
    */
@@ -117,22 +141,15 @@ class Config {
     return super.required_services_or_defs = dict
   }
 
-  set roots(v) { set (this, 'roots', v) }
-  get roots() {
-    return this.roots = Object.values(this.folders) .concat ([ 'schema', 'services' ])
+  get profiles() {
+    return super.profiles = Array.from (this._profiles)
   }
 
-  get tmp() {
-    return set (this, 'tmp', require('os').tmpdir())
+  get roots() {
+    return super.roots = Object.values(this.folders) .concat ([ 'schema', 'services' ])
   }
 
-  /**
-   * Retrieves the value for a config option, specified as a property path.
-   */
-  get (option) {
-    if (!option)  return
-    return option.split('.').reduce ((p,n)=> p && p[n], this)
-  }
+  get tmp() { return super.tmp = require('os').tmpdir() }
 
   /**
    * Provides access to system defaults for cds env.
@@ -163,24 +180,19 @@ class Config {
     return Array.from (new Set(Array.from(this._profiles._defined).map( profile => profile.endsWith("!") ? profile.slice(0, -1) : profile)))
   }
 
-  get profiles() {
-    return super.profiles = Array.from (this._profiles)
-  }
-
 
-//////////////////////////////////////////////////////////////////////////
-//
-//    DANGER ZONE!
-//    The following are internal APIs which can always change!
-//
+  //////////////////////////////////////////////////////////////////////////
+  //
+  //    DANGER ZONE!
+  //    The following are internal APIs which can always change!
+  //
 
 
-/**
- * Load from JSON file or directory
- *
- * No profile support!
- */
-_loadFromPath (_path, _basePath) {
+  /**
+   * Load from JSON file or directory
+   * No profile support!
+   */
+  _loadFromPath (_path, _basePath) {
     if (_basePath && !path.isAbsolute(_path)) _path = path.join(_basePath, _path)
     const json = _readJson (_path) || _readFromDir (_path)
     if (json) this.add (json, _path, new Set())
@@ -191,13 +203,6 @@ _loadFromPath (_path, _basePath) {
     if (json) this.add (_conf (json), file, profiles, profiles_only)
   }
 
-  add (conf, /*from:*/ _src, profiles = this._profiles, profiles_only = false) {
-    if (!conf)  return this
-    if (_src)  this._sources.push (_src)
-    _merge (this, conf, profiles, undefined, profiles_only)
-    return this
-  }
-
   _add_to_process_env (cwd, filename) {
     const file = path.resolve (cwd,filename)
     try {
@@ -246,18 +251,32 @@ _loadFromPath (_path, _basePath) {
   }
 
   _link_required_services () {
-    const { requires } = this, protos = requires && requires._prototypes || {}
-    for (let each in requires) {
-      requires[each] = _merged (each)
-      // if we got an invalid value, remove it (would anyways cause trouble down the road)
-      if (!requires[each])  delete requires[each]
+    const { requires } = this; if (!requires) return
+    const kinds = requires.kinds
+    if (kinds) {
+      Object.defineProperty (requires, 'kinds', { value:kinds, enumerable:false }) // for cds env
+      Object.setPrototypeOf (requires, kinds)
+      for (let each in kinds)  kinds[each] = _linked(each)
     }
-    function _merged (key) {
-      const entry = requires[key] || protos[key]
-      if (!entry || entry._is_merged || entry.kind === key || !(entry.kind in requires) && !(entry.kind in protos)) return entry
-      const clone = _merge ({}, _merged (entry.kind))        // first apply inherited data
-      _merge (clone, entry, false, false) // then apply overridden data
-      return Object.defineProperty (clone, '_is_merged', {value:true})
+    for (let each of Object.keys(requires)) {
+      const e = requires[each] = _linked(each)
+      if (!e) delete requires[each] // skip invalid values
+    }
+    function _linked (key) {
+      const e = requires[key]; if (!e || e._is_linked || e.kind === key) return e
+      let linked
+      if (e === true) {
+        if (key in kinds) linked = kinds[key]
+        else return e
+      }
+      else if (e.kind in requires) {
+        linked = _merge ({}, _linked(e.kind))  // first apply inherited data
+        const {kind} = linked                 // get the kind from prototype
+        _merge (linked, e, false, false)     // then apply overridden data
+        if (kind) linked.kind = kind        // inherited kind wins
+      }
+      else linked = e
+      return Object.defineProperty (linked, '_is_linked', {value:true})
     }
   }
 
@@ -267,7 +286,7 @@ _loadFromPath (_path, _basePath) {
     if (!VCAP_SERVICES) return
     try {
       const vcaps = JSON.parse (VCAP_SERVICES)
-      const any = _add_vcap_services_to (this, vcaps)
+      const any = this._add_vcap_services_to (vcaps)
       if (any)  this._sources.push ('{VCAP_SERVICES}')
     } catch(e) {
       throw new Error ('[cds.env] - failed to parse VCAP_SERVICES:\n  '+ e.message)
@@ -279,10 +298,26 @@ _loadFromPath (_path, _basePath) {
    * locally with credentials (hybrid mode).
    */
   _emulate_vcap_services() {
-    if (!(this.features && this.features.emulate_vcap_services)) return
-    process.env.VCAP_SERVICES = JSON.stringify(build_vcap_services(this))
+    const vcap_services = {}, names = new Set()
+    for (const service in this.requires) {
+      let { vcap, credentials, binding } = this.requires[service]
+      // "binding.vcap" is chosen over "vcap" because it is meta data resolved from the real service (-> cds bind)
+      if (binding && binding.vcap) vcap = binding.vcap
+      if (vcap && vcap.label && credentials && Object.keys(credentials).length > 0) {
+        // Only one entry for a (instance) name. Generate name from label and plan if not given.
+        const { label, plan } = vcap
+        const name = vcap.name || `instance:${label}:${plan || ""}`
+        if (names.has(name)) continue
+        names.add(name)
+
+        if (!vcap_services[label]) vcap_services[label] = []
+        vcap_services[label].push(Object.assign({ name }, vcap, { credentials }))
+      }
+    }
+    process.env.VCAP_SERVICES = JSON.stringify(vcap_services)
   }
 
+
 //////////////////////////////////////////////////////////////////////////
 //
 //    FORBIDDEN ZONE!
@@ -295,7 +330,7 @@ _loadFromPath (_path, _basePath) {
   // FOR TESTS ONLY! --> PLEASE: tests should test public APIs (only)
   _for_tests (...conf) {
     const env = new Config('cds')
-    this._for_tests.vcaps = (vcaps) => { _add_vcap_services_to (env, vcaps)}
+    this._for_tests.vcaps = (vcaps) => { env._add_vcap_services_to (vcaps)}
     // merge all configs, then resolve profiles (same as in 'for' function above)
     for (let c of [...conf].reverse())  _merge(env, c, env._profiles)
     return env
@@ -305,6 +340,47 @@ _loadFromPath (_path, _basePath) {
     _merge (this, src, this._profiles)
     return this
   }
+
+  // API for binding resolution in @sap/cds-dk
+  _find_credentials_for_required_service(service, conf, vcaps) {
+    return conf.vcap && _fetch (conf.vcap) ||  //> alternatives, e.g. { name:'foo', tag:'foo' }
+      _fetch ({ name: service })  ||
+      _fetch ({ tag: this._context+':'+service }) ||
+      _fetch ({ tag: conf.dialect || conf.kind }) || // important for hanatrial, labeled 'hanatrial', tagged 'hana'
+      _fetch ({ label: conf.dialect || conf.kind })
+
+    function _fetch (predicate) {
+      for (let k of Object.keys(predicate).reverse()) {
+        const v = predicate[k]; if (!v) continue
+        const filter = k === 'tag' ? e => _array(e,'tags').includes(v) : e => e[k] === v
+        for (let stype in vcaps) {
+          const found = _array(vcaps,stype) .find (filter)
+          if (found)  return found
+        }
+      }
+    }
+
+    function _array(o,p) {
+      const v = o[p]
+      if (!v) return []
+      if (Array.isArray(v)) return v
+      throw new Error(`Expected VCAP entry '${p}' to be an array, but was: ${require('util').inspect(vcaps)}`)
+    }
+  }
+
+  _add_vcap_services_to (vcaps={}) {
+    let any
+    for (let service in this.requires) {
+      const conf = this.requires [service]
+      if (!conf) continue
+      const { credentials } = this._find_credentials_for_required_service(service, conf, vcaps) || {}
+      if (credentials)  {
+        // Merge `credentials`.  Needed because some app-defined things like `credentials.destination` must survive.
+        any = conf.credentials = Object.assign ({}, conf.credentials, credentials)
+      }
+    }
+    return !!any
+  }
 }
 
 
@@ -349,6 +425,27 @@ function _merge (dst, src, _profiles, _cloned, _profiles_only = false) {
   return dst
 }
 
+function _value4 (val) {
+  if (val && val[0] === '{') try { return JSON.parse(val) } catch(e) {/* ignored */}
+  if (val && val[0] === '[') try { return JSON.parse(val) } catch(e) {/* ignored */}
+  if (val === 'true')  return true
+  if (val === 'false')  return false
+  if (!isNaN(val))  return parseFloat(val)
+  return val
+}
+
+function _readJson (file) {
+  try {
+    const src = fs.readFileSync (require.resolve (file))
+    return JSON.parse (src)
+  } catch (e) {
+    if (e instanceof SyntaxError)  console.error(`Error parsing '${file}': ${e.message}`)
+    else if (e.code !== 'MODULE_NOT_FOUND')  console.error(e.message)
+  }
+}
+
+
+
 function _readFromDir (p, isDir) {
   if (typeof isDir === "undefined") {
     try {
@@ -379,118 +476,21 @@ function _readFromDir (p, isDir) {
   } else {
     return _value4(fs.readFileSync(p, "utf-8"))
   }
-}
-
-function isFile(p, entry) {
-  if (entry.isFile()) return true
-  if (entry.isSymbolicLink()) {
-    // Kubernetes credentials use symlinks
-    const target = fs.realpathSync(p)
-    const targetStat = fs.statSync(target)
 
-    if (targetStat.isFile()) return true
-  }
-  return false
-}
+  function isFile(p, entry) {
+    if (entry.isFile()) return true
+    if (entry.isSymbolicLink()) {
+      // Kubernetes credentials use symlinks
+      const target = fs.realpathSync(p)
+      const targetStat = fs.statSync(target)
 
-function _value4 (val) {
-  if (val && val[0] === '{') try { return JSON.parse(val) } catch(e) {/* ignored */}
-  if (val && val[0] === '[') try { return JSON.parse(val) } catch(e) {/* ignored */}
-  if (val === 'true')  return true
-  if (val === 'false')  return false
-  if (!isNaN(val))  return parseFloat(val)
-  return val
-}
-
-
-function _add_vcap_services_to (env, vcaps={}) {
-  let any
-  for (let service in env.requires) {
-    const conf = env.requires [service]
-    if (!conf) continue
-    const { credentials } = (
-      conf.vcap && _fetch (conf.vcap) ||  //> alternatives, e.g. { name:'foo', tag:'foo' }
-      _fetch ({ name: service })  ||
-      _fetch ({ tag: env._context+':'+service }) ||
-      _fetch ({ tag: conf.dialect || conf.kind }) || // important for hanatrial, labeled 'hanatrial', tagged 'hana'
-      _fetch ({ label: conf.dialect || conf.kind }) ||
-      {/* not found */}
-    )
-    // Merge `credentials`.  Needed because some app-defined things like `credentials.destination` must survive.
-    if (credentials)  {
-      any = conf.credentials = Object.assign ({}, conf.credentials, credentials)
-    }
-  }
-  return any
-
-  function _fetch (predicate) {
-    for (let k of Object.keys(predicate).reverse()) {
-      const v = predicate[k]; if (!v) continue
-      const filter = k === 'tag' ? e => _array(e,'tags').includes(v) : e => e[k] === v
-      for (let stype in vcaps) {
-        const found = _array(vcaps,stype) .find (filter)
-        if (found)  return found
-      }
+      if (targetStat.isFile()) return true
     }
+    return false
   }
-
-  function _array(o,p) {
-    const v = o[p]
-    if (!v) return []
-    if (Array.isArray(v)) return v
-    throw new Error(`Expected VCAP entry '${p}' to be an array, but was: ${require('util').inspect(vcaps)}`)
-  }
-
-}
-
-function _readJson (file) {
-  try {
-    const src = fs.readFileSync (require.resolve (file))
-    return JSON.parse (src)
-  } catch (e) {
-    if (e instanceof SyntaxError)  console.error(`Error parsing '${file}': ${e.message}`)
-    else if (e.code !== 'MODULE_NOT_FOUND')  console.error(e.message)
-  }
-}
-
-function _determineProfilesFrom (env = process.env) {
-  if (env.NODE_ENV !== 'production' && !/\b(development|production)\b/.test(env.CDS_ENV)) {
-    if (env.CDS_ENV)  env.CDS_ENV += ',development'
-    else  env.CDS_ENV = 'development'
-  }
-  const split = (x) => env[x] ? env[x].split (/\s*,\s*/) : []
-  const profiles = [ ...split ('NODE_ENV'), ...split ('CDS_ENV') ]
-  return new Set (profiles)
-}
-
-
-function set (o,p,value) {
-  Object.defineProperty (o, p, {value,configurable:true,writable:true})
-  return value
 }
 
-function build_vcap_services(env) {
-  let v = {}
-  let names = new Set()
-
-  for (const service in env.requires) {
-    let { vcap, credentials, binding } = env.requires[service]
-    // "binding.vcap" is chosen over "vcap" because it is meta data resolved from the real service (-> cds bind)
-    if (binding && binding.vcap) vcap = binding.vcap
-    if (vcap && vcap.label && credentials && Object.keys(credentials).length > 0) {
-      // Only one entry for a (instance) name. Generate name from label and plan if not given.
-      const { label, plan } = vcap
-      const name = vcap.name || `instance:${label}:${plan || ""}`
-      if (names.has(name)) continue
-      names.add(name)
-
-      if (!v[label]) v[label] = []
-      v[label].push(Object.assign({ name }, vcap, { credentials }))
-    }
-  }
 
-  return v
-}
 
 /** @type Config & typeof DEFAULTS */
 module.exports = Config.prototype.for('cds')

package/lib/env/presets.js

@@ -1,3 +1,4 @@
+// REVISIT: Looks ver hard-coded -> move this to consumers?
 module.exports = function (conf) {
   const { features } = conf
   if (!features) return

package/lib/env/requires.js

@@ -1,16 +1,21 @@
 const _runtime = '../../libx/_runtime'
 
-module.exports = {
-  "db": undefined,
-  "multitenancy": undefined,
-  "app-service": {
-    // this is the default implementation used for provided services
-    impl: `${_runtime}/cds-services/services/Service.js`
-  },
-  "auth": {
+exports = module.exports = {
+
+  db: undefined,
+  messaging: undefined,
+  multitenancy: undefined,
+
+  auth: {
     '[development]': { kind: 'mocked-auth' },
     '[production]': { kind: 'jwt-auth' }
   },
+
+}
+
+
+const _authentication_strategies = {
+
   "dummy-auth": {
     strategy: 'dummy',
   },
@@ -27,50 +32,66 @@ module.exports = {
   },
   "jwt-auth": {
     strategy: 'JWT',
+    vcap: { label: 'xsuaa' }
   },
-  "xsuaa-auth": {
+  "xsuaa": {
     strategy: 'xsuaa',
+    vcap: { label: 'xsuaa' }
   },
-  "dwc-auth": {
-    strategy: 'dwc',
+
+}
+
+
+const _services = {
+
+  "app-service": {
+    // this is the default implementation used for provided services
+    impl: `${_runtime}/cds-services/services/Service.js`
   },
-  destinations: {
-    vcap: {
-      label: 'destination'
-    }
+  "rest": {
+    impl: `${_runtime}/remote/Service.js`
   },
-  xsuaa: {
-    vcap: {
-      label: 'xsuaa'
-    }
+  "odata": {
+    impl: `${_runtime}/remote/Service.js`
+  },
+  "odata-v2": { // REVISIT: we should introduce .version
+    impl: `${_runtime}/remote/Service.js`
+  },
+  "odata-v4": { // REVISIT: we should introduce .version
+    impl: `${_runtime}/remote/Service.js`
   },
-  monitoring: undefined,
-  logging: undefined,
-  audit: undefined,
+
+}
+
+
+const _databases = {
+
   "sql": {
     '[development]': { kind: 'sqlite', credentials: { url: ':memory:' } },
     '[production]': { kind: 'hana' },
   },
   "sqlite": _compat_to_use({
-    dialect: 'sqlite', credentials: { url: 'sqlite.db' },
+    credentials: { url: 'sqlite.db' },
     impl: `${_runtime}/sqlite/Service.js`,
   }),
   "hana": _compat_to_use ({
-    dialect: 'hana',
     impl: `${_runtime}/hana/Service.js`,
   }),
-  "rest": {
-    impl: `${_runtime}/remote/Service.js`
-  },
-  "odata": {
-    impl: `${_runtime}/remote/Service.js`
-  },
-  "odata-v2": {
-    kind: 'odata'
-  },
-  "odata-v4": {
-    kind: 'odata'
-  },
+  "hana-cloud": _compat_to_use ({
+    kind: 'hana', "deploy-format": "hdbtable",
+  }),
+  "hana-mt": _compat_to_use ({
+    kind: 'hana', "deploy-format": "hdbtable",
+    "vcap": {
+      "label": "service-manager"
+    }
+  }),
+
+}
+
+
+const _messaging = {
+
   "local-messaging": {
     impl: `${_runtime}/messaging/service.js`,
     local: true
@@ -112,28 +133,78 @@ module.exports = {
   "composite-messaging": {
     impl: `${_runtime}/messaging/composite.js`
   },
-  "audit-log": {
+  "mtx-messaging": {
+    kind: "local-messaging",
+    "[production]": {
+      kind: "redis-messaging"
+    }
+  },
+  "redis-messaging": {
+    impl: `${_runtime}/messaging/redis-messaging.js`,
+    vcap: { label: "redis-cache" },
+    outbox: {}
+  },
+
+  "persistent-outbox": {
+    model: "@sap/cds/srv/outbox",
+    maxAttempts: 20,
+    chunkSize: 100
+  },
+
+}
+
+
+const _multitenancy = {
+}
+
+
+const _extensibility = {
+
+  "uiflex": {
+    model: "@sap/cds/srv/flex"
+  },
+
+}
+
+
+
+const _platform_services = {
+
+  "audit-log-service": {
     impl: `${_runtime}/audit/Service.js`,
-    // REVISIT: how to load model? -> see _prototypes below
     // model: 'AuditLogService.cds',
     outbox: {},
     vcap: { label: "auditlog" },
   },
 
-  _prototypes: {
-    "uiflex": {
-      model: "@sap/cds/srv/flex"
-    },
-    "persistent-outbox": {
-      model: "@sap/cds/srv/outbox",
-      maxAttempts: 20,
-      chunkSize: 100
-    },
-  }
+  "audit-log-to-console": {
+    kind: "audit-log-service",
+    credentials: { logToConsole: true }
+  },
+
+  destinations: {
+    vcap: {
+      label: 'destination'
+    }
+  },
+
+  approuter: undefined,
+
+}
+
+
+exports.kinds = {
+  ..._authentication_strategies,
+  ..._databases,
+  ..._services,
+  ..._messaging,
+  ..._multitenancy,
+  ..._extensibility,
+  ..._platform_services,
 }
 
 
 function _compat_to_use(o) { return Object.defineProperties (o,{
   // NOTE: Property .use is for compatibility only -> use .dialect instead!
-  use: { get(){ return this.dialect }, enumerable:true },
+  use: { get(){ return this.dialect || this.kind }, configurable:true, enumerable:true },
 })}