@sap/cds 5.9.6 → 6.0.1

package/lib/deploy.js

@@ -12,6 +12,7 @@ exports = module.exports = function cds_deploy (model,options) { return {
 
   /** @param {cds.Service} db */
   async to (db, o = options || cds.options || {}) {
+    if (!model)  throw new Error('Must provide a model or a path to model, received: ' + model)
     const LOG = o.silent || !cds.log('deploy')._info ? ()=>{} : console.log
 
     if (model && !model.definitions) {
@@ -110,7 +111,7 @@ exports.create = async function (db, csn=db.model, o) {
       console.log(); for (let each of drops) console.log(each)
       console.log(); for (let each of creates) console.log(each,'\n')
       return
-    } else await db.tx (async tx => {
+    } else return db.tx (async tx => {
       await tx.run(drops)
       await tx.run(creates)
       return true
@@ -120,21 +121,23 @@ exports.create = async function (db, csn=db.model, o) {
 
 
 exports.init = (db, csn=db.model, log=()=>{}) => db.tx (async tx => {
-  cds.context = tx //> registers tx as root transaction
-  const resources = await exports.resources(csn), inits=[], err = new Error
+  const resources = await exports.resources(csn), inits=[]
   for (let [file,e] of Object.entries(resources)) {
     if (e === '*') { // init.js/ts
-      const x = require(file); if (!x) continue
+      const { pathToFileURL } = require('url')  // on Windows, must use a file: URL for ESM import
+      let x = typeof jest !== 'undefined' ? require(file) : await import(pathToFileURL(file).href); if (!x) continue
+      if (x.default)  x = x.default  // default ESM export
+      inits.push (!x.then && typeof x === 'function' ? x(db,csn) : x)
       log (file)
-      inits.push (!x.then && typeof x === 'function' ? x(db) : x)
     } else { // from .csv or .json
       const INSERT_into = _from_csv_or_json [path.extname(file)]
       const src = await read(file,'utf8'); if (!src) continue
       const q = INSERT_into (e,src); if (!q) continue
       log (file,e)
-      inits.push (tx.run(q) .catch (e => { throw Object.assign (e,{
-        message: 'in cds.deploy(): ' + e.message +'\n'+ inspect(q),
-      })}))
+      inits.push (tx.run(q) .catch (e => {
+        Error.captureStackTrace(e)
+        throw Object.assign (e, { message: 'in cds.deploy(): ' + e.message +'\n'+ inspect(q) })
+      }))
     }
   }
   await Promise.all (inits)

package/lib/env/defaults.js

@@ -20,10 +20,9 @@ module.exports = {
     skip_unused: true,
     one_model: true,
     localized: true,
-    assert_integrity: true,
-    assert_integrity_type: 'RT',
+    assert_integrity: false,
     cds_tx_protection: true,
-    cds_tx_inheritance: true,
+    cds_tx_inheritance: true
   },
 
   log: {
@@ -53,11 +52,13 @@ module.exports = {
   },
 
   i18n: {
+    file: 'i18n', // file basename w/o extension
     folders: ['_i18n', 'i18n', 'assets/i18n'],
     for_sqlite: ['de', 'fr'],
     for_sql: ['de', 'fr'],
     languages: 'all', // or array.  'all': whatever language files are found next to models
     default_language: 'en',
+    fallback_bundle: '',
     preserved_locales: [
       // IMPORTANT: Never, never modify this list, as that would break existing projects !!!!
       // Projects can and have to override if they want something different.

package/lib/env/index.js

@@ -2,6 +2,7 @@ const { isfile, fs, path } = require('../utils')
 const DEFAULTS = require('./defaults'), defaults = require.resolve ('./defaults')
 const compat = require('./compat')
 const presets = require('./presets')
+const serviceBindings = require('./serviceBindings');
 
 
 /**
@@ -16,7 +17,7 @@ class Config {
    * @returns {Config & typeof DEFAULTS}
    */
   for (context, cwd, _defaults=true) {
-    if (!cwd) cwd = global.cds && global.cds.root || process.cwd()
+    if (!cwd) cwd = this._home || require('..').root || process.cwd()
     return new Config (context, cwd, _defaults)
   }
 
@@ -63,14 +64,17 @@ class Config {
       }
     }
 
-    // 4. add process env
+    // 4. link dependant services (through kind/use)
+    this._link_required_services()
+
+    // 5. add process env
     this._add_process_env(_context, _home)
 
-    // 6. link dependant services (through kind/use)
+    // 6. link dependant services again -> e.g. to allow things like CDS_requires_db=sql
     this._link_required_services()
 
-    // 7. complete service configurations from VCAP
-    this._add_vcap_services (process.env.VCAP_SERVICES)
+    // 7. complete service configurations from cloud service bindings
+    this._add_cloud_service_bindings({ VCAP_SERVICES: process.env.VCAP_SERVICES, SERVICE_BINDING_ROOT: process.env.SERVICE_BINDING_ROOT })
 
     // 8. Add compatibility for mtx
     if (this.requires && this.requires.db) {
@@ -128,11 +132,12 @@ class Config {
 
   /**
    * This is `this.requires` plus additional entries for all cds.required.<name>.service
+   * @returns {import('./requires')}
    */
   get required_services_or_defs() {
     const dict = Object.create (this.requires)
     for (let [name,e] of Object.entries (this.requires)) if (e.service) {
-      if (e.service in dict && e.service !== name) {
+      if (e.service in dict && !e.override && e.service !== name) {
         console.error (`Datasource name '${e.service}' conflicts with 'service' definition referred to in 'cds.requires.${name}':`, e)
         throw new Error (`Datasource name '${e.service}' conflicts with service definition`)
       }
@@ -242,6 +247,7 @@ class Config {
       for (var o=config,next;;) {
         next = path.shift()
         if (!path.length) break
+        if (!path[0]) next = next+'-'+path.shift()+path.shift() // foo__bar -> foo-bar
         o = o[next] || (o[next] = {})
       }
       o[next] = _value4(env[p])
@@ -252,31 +258,36 @@ class Config {
 
   _link_required_services () {
     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)
-    }
-    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
+    const kinds = requires.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, kinds[each])
+    for (let each in requires) requires[each] = _linked (each, requires[each])
+    function _linked (key, val) {
+      if (!val || val._is_linked) return val
+      if (val === true) {
+        let x = kinds[key]
+        if (!x) return val
+        else val = x
+      }
+      if (typeof val === 'string') {
+        let x = kinds[val] || kinds[val+'-'+key] || kinds[key+'-'+val]
+        if (!x) return val
+        else val = { kind: val }
       }
-      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
+      const preset1 = kinds[key]
+      if (typeof preset1 === 'object' && preset1 !== val) {
+        const top = val, base = _merge ({},_linked(key,preset1)), {kind} = base
+        val = _merge (base, top, false, false)  // apply/override with top-level data
+        if (kind) val.kind = kind              // but inherited kind wins
       }
-      else linked = e
-      return Object.defineProperty (linked, '_is_linked', {value:true})
+      let k = val.kind, p, preset = k && kinds[p=k] || kinds[p=k+'-'+key] || kinds[p=key+'-'+k]
+      if (typeof preset === 'object' && preset !== val) {
+        const top = val, base = _merge ({},_linked(p,preset)), {kind} = base
+        val = _merge (base, top, false, false)  // apply/override with top-level data
+        if (kind) val.kind = kind              // but inherited kind wins
+      }
+      return Object.defineProperty (val, '_is_linked', {value:true})
     }
   }
 
@@ -293,6 +304,34 @@ class Config {
     }
   }
 
+  _add_cloud_service_bindings({ VCAP_SERVICES, SERVICE_BINDING_ROOT }) {
+    let bindings, bindingsSource
+
+    if (!this.requires)  return
+    if (VCAP_SERVICES && !(this.features && this.features.vcaps == false)) {
+      try {
+        bindings = JSON.parse(VCAP_SERVICES)
+        bindingsSource = '{VCAP_SERVICES}'
+      } catch(e) {
+        throw new Error ('[cds.env] - failed to parse VCAP_SERVICES:\n  '+ e.message)
+      }
+    }
+
+    if (!bindings && SERVICE_BINDING_ROOT) {
+      bindings = serviceBindings(SERVICE_BINDING_ROOT)
+      bindingsSource = SERVICE_BINDING_ROOT
+    }
+
+    if (bindings) {
+      try {
+        const any = this._add_vcap_services_to(bindings)
+        if (any)  this._sources.push(bindingsSource)
+      } catch(e) {
+        throw new Error(`[cds.env] - failed to add service bindings from ${bindingsSource}:\n ${e.message}`);
+      }
+    }
+  }
+
   /**
    * Build VCAP_SERVICES for compatibility (for example for CloudSDK) or for running
    * locally with credentials (hybrid mode).
@@ -347,7 +386,8 @@ class Config {
       _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 })
+      _fetch ({ label: conf.dialect || conf.kind }) ||
+      _fetch ({ type: conf.dialect || conf.kind })
 
     function _fetch (predicate) {
       for (let k of Object.keys(predicate).reverse()) {
@@ -493,5 +533,5 @@ function _readFromDir (p, isDir) {
 
 
 /** @type Config & typeof DEFAULTS */
-module.exports = Config.prototype.for('cds')
+module.exports = Config.prototype
 /* eslint no-console:0 */

package/lib/env/presets.js

@@ -6,9 +6,6 @@ module.exports = function (conf) {
   // integrity checks
   if (typeof features.assert_integrity === 'string') {
     switch (features.assert_integrity) {
-      case 'individual':
-        // > keep as is
-        break
       case 'off':
         features.assert_integrity = false
         break
@@ -20,19 +17,9 @@ module.exports = function (conf) {
         features.assert_integrity = true
         features.assert_integrity_type = 'DB'
         break
-      // *-opt-in options not officially documented!
-      case 'app-opt-in':
-        features.assert_integrity = 'individual'
-        features.assert_integrity_type = 'RT'
-        break
-      case 'db-opt-in':
-        features.assert_integrity = 'individual'
-        features.assert_integrity_type = 'DB'
-        break
       default:
         // > invalid -> set to default
-        features.assert_integrity = true
-        features.assert_integrity_type = 'RT'
+        features.assert_integrity = false
     }
   }
 

package/lib/env/requires.js

@@ -16,18 +16,22 @@ exports = module.exports = {
 
 const _authentication_strategies = {
 
-  "dummy-auth": {
-    strategy: 'dummy',
-  },
-  "basic-auth": {
-    kind: "mocked-auth"
-  },
+  "basic-auth": "mocked-auth",
   "mocked-auth": {
     strategy: 'mock',
     users: {
       alice: { roles: ['admin'] },
-      bob: { roles: ['builder'] },
+      bob:   { roles: ['builder'] },
+      carol: { tenant: 't1', roles: ['admin', 'cds.Subscriber', 'cds.ExtensionDeveloper', 'cds.UIFlexDeveloper'] },
+      dave:  { tenant: 't1', roles: ['cds.Subscriber'], features: [] }, // user-specific features
+      erin:  { tenant: 't2', roles: ['admin', 'cds.Subscriber', 'cds.ExtensionDeveloper'] },
+      fred:  { tenant: 't2', roles: [], features: ['isbn'] },
+      yves:  { roles: ['internal-user'] },
       '*': true
+    },
+    tenants: {
+      t1: { features: [ 'isbn' ], }, // tenant-specific features
+      t2: { features: '*', },
     }
   },
   "jwt-auth": {
@@ -38,6 +42,9 @@ const _authentication_strategies = {
     strategy: 'xsuaa',
     vcap: { label: 'xsuaa' }
   },
+  "dummy-auth": {
+    strategy: 'dummy',
+  },
 
 }
 
@@ -49,16 +56,24 @@ const _services = {
     impl: `${_runtime}/cds-services/services/Service.js`
   },
   "rest": {
-    impl: `${_runtime}/remote/Service.js`
+    impl: `${_runtime}/remote/Service.js`,
+    external: true
   },
   "odata": {
-    impl: `${_runtime}/remote/Service.js`
+    impl: `${_runtime}/remote/Service.js`,
+    external: true
   },
   "odata-v2": { // REVISIT: we should introduce .version
-    impl: `${_runtime}/remote/Service.js`
+    impl: `${_runtime}/remote/Service.js`,
+    external: true
   },
   "odata-v4": { // REVISIT: we should introduce .version
-    impl: `${_runtime}/remote/Service.js`
+    impl: `${_runtime}/remote/Service.js`,
+    external: true
+  },
+  "graphql": { // REVISIT: we should introduce .version
+    impl: `${_runtime}/remote/Service.js`,
+    external: true
   },
 
 }
@@ -99,7 +114,7 @@ const _messaging = {
   "file-based-messaging": {
     outbox: {},
     impl: `${_runtime}/messaging/file-based.js`,
-    credentials: { file:'~/.cds-msg-box' }
+    file:'~/.cds-msg-box'
   },
   "default-messaging": {
     "[development]": { kind: "local-messaging" },
@@ -148,21 +163,57 @@ const _messaging = {
   "persistent-outbox": {
     model: "@sap/cds/srv/outbox",
     maxAttempts: 20,
-    chunkSize: 100
+    chunkSize: 100,
+    storeLastError: true
   },
 
 }
 
 
-const _multitenancy = {
-}
+const _mtx_services = {
 
+  "toggles": {
+    model: "@sap/cds/srv/mtx"
+  },
+  "cds.xt.ModelProviderService": {
+    model: "@sap/cds/srv/model-provider"
+  },
+  "cds.xt.ModelProviderService-in-sidecar": {
+    "[development]": { root: "../.." }, // sidecar is expected to reside in ./mtx/sidecar
+    "[production]": { root: "_main" },
+    "[prod]": { root: "_main" }, // for simulating production in local tests
+  },
+  "cds.xt.ModelProviderService-from-sidecar": {
+    kind: 'rest'
+  },
 
-const _extensibility = {
+  "multitenancy": {
+    model: "@sap/cds/srv/mtx",
+    kind: "saas-registry",
+  },
+  "cds.xt.SaasProvisioningService": {
+    model: "@sap/cds-mtxs/srv/cf/saas-provisioning-service",
+  },
+  "cds.xt.DeploymentService": {
+    model: "@sap/cds-mtxs/srv/deployment-service",
+  },
+  "cds.xt.DeploymentService-in-sidecar": {
+  },
+  "cds.xt.DeploymentService-from-sidecar": {
+    kind: 'rest'
+  },
 
-  "uiflex": {
-    model: "@sap/cds/srv/flex"
+  "extensions": {
+    model: "@sap/cds/srv/extensions",
+  },
+  "extensibility": {
+    model: [ "@sap/cds/srv/mtx", "@sap/cds/srv/extensions" ]
+  },
+  "cds.xt.ExtensibilityService": {
+    model: "@sap/cds/srv/extensibility-service",
+    tenantCheckInterval: 10000
   },
+  "uiflex": "extensibility", // REVISIT: temporary for compatibility with cds-mtxs tests -> eliminate "uiflex" later
 
 }
 
@@ -198,8 +249,7 @@ exports.kinds = {
   ..._databases,
   ..._services,
   ..._messaging,
-  ..._multitenancy,
-  ..._extensibility,
+  ..._mtx_services,
   ..._platform_services,
 }
 

package/lib/env/serviceBindings.js

@@ -0,0 +1,147 @@
+const fs = require('fs')
+const assert = require('assert')
+const path = require('path')
+
+const _debug = process.env.DEBUG && process.env.DEBUG.match(/\benv\b/);
+const debug = msg => console.log(msg);
+/* eslint no-console:0 */
+
+
+const isDirectory = dirPath => fs.statSync(dirPath).isDirectory()
+
+function readFiles(dirPath) {
+  const result = {}
+  for (const dirEntry of fs.readdirSync(dirPath, { withFileTypes: true })) {
+    const filePath = path.join(dirPath, dirEntry.name)
+    if (isFile(filePath, dirEntry)) {
+      result[dirEntry.name] = fs.readFileSync(filePath, 'utf8')
+    }
+  }
+  return result
+}
+
+const DEFAULT_META_DATA_PROPERTIES = { type: true, provider: true }
+
+function parseJsonSafe(str) {
+  try {
+    return JSON.parse(str)
+  } catch (error) {
+    return undefined
+  }
+}
+
+function buildBindingWithoutMetaData(properties) {
+  const binding = { credentials: {} }
+
+  for (const propertyName in properties) {
+    if (propertyName in DEFAULT_META_DATA_PROPERTIES) {
+      binding[propertyName] = properties[propertyName]
+    } else {
+      binding.credentials[propertyName] = properties[propertyName]
+    }
+  }
+
+  return binding
+}
+
+function parseProperties(properties, metaData = [], bindingPath) {
+  const result = {}
+
+  for (const metaDataProperty of metaData) {
+    const { name } = metaDataProperty
+    const text = properties[name]
+    if (name && typeof text !== 'undefined') {
+      let value
+      switch (metaDataProperty.format) {
+        case 'text':
+          result[name] = text
+          break
+        case 'json':
+          value = parseJsonSafe(text)
+          if (metaDataProperty.container) {
+            Object.assign(result, value)
+          } else {
+            result[name] = value
+          }
+          break
+        default:
+          _debug && debug(`Unexpected format "${metaDataProperty.format}" in service binding "${bindingPath}"`)
+      }
+    } else {
+      _debug && debug(`Missing property "${name}" in service binding "${bindingPath}"`)
+    }
+  }
+
+  return result
+}
+
+function readBinding(bindingPath, bindingName) {
+  const properties = readFiles(bindingPath)
+  return parseBinding(bindingPath, bindingName, properties)
+}
+
+function parseBinding(bindingPath, bindingName, properties) {
+  const metaDataString = properties['.metadata']
+  let metaData
+  if (metaDataString) {
+    metaData = parseJsonSafe(metaDataString)
+    if (typeof metaData === 'undefined' && _debug) debug(`Cannot parse JSON: ${bindingPath}/.metadata`)
+  }
+
+  let binding
+  if (metaData) {
+    binding = parseProperties(properties, metaData.metaDataProperties, bindingPath)
+    binding.credentials = parseProperties(properties, metaData.credentialProperties, bindingPath)
+  } else {
+    binding = buildBindingWithoutMetaData(properties)
+  }
+
+  if (!binding.type) {
+    _debug && debug(`Missing type property for service binding "${bindingPath}"`)
+    return undefined
+  }
+
+  binding.name = bindingName
+  return binding
+}
+
+function readServiceBindingsServicesFromPath(serviceBindingRoot) {
+  assert(isDirectory(serviceBindingRoot), 'secrets path must be a directory')
+
+  const bindingsForService = {}
+  for (const bindingEntry of fs.readdirSync(serviceBindingRoot, { withFileTypes: true })) {
+    if (bindingEntry.isDirectory()) {
+      const bindingPath = path.join(serviceBindingRoot, bindingEntry.name)
+      const binding = readBinding(bindingPath, bindingEntry.name)
+      if (!binding) continue
+      const type = binding.type
+      const bindings = bindingsForService[type] || (bindingsForService[type] = [])
+      bindings.push(binding)
+    }
+  }
+  return Object.keys(bindingsForService).length > 0 ? bindingsForService : undefined
+}
+
+function serviceBindings(serviceBindingRoot) {
+  serviceBindingRoot = serviceBindingRoot || process.env.SERVICE_BINDING_ROOT
+  if ((typeof serviceBindingRoot === 'string' && serviceBindingRoot.length > 0)) {
+    return fs.existsSync(serviceBindingRoot) ? readServiceBindingsServicesFromPath(serviceBindingRoot) : undefined
+  } else {
+    return undefined
+  }
+}
+
+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
+}
+
+module.exports = serviceBindings
+module.exports.parseBinding = parseBinding // required by "cds bind"