@sap/cds 5.6.4 → 5.7.1

package/bin/build/provider/hana/migrationtable.js

@@ -1,5 +1,4 @@
 const { fs } = require('@sap/cds-foss')
-
 class MigrationTableParser {
   constructor() {
   }
@@ -212,17 +211,17 @@ class MigrationTableModel {
    * into the current branch representing the extension.
    * <code>extension.merge(base, targetTable)</code>
    *
-   *    A---B---E---F extension
-   *   /
-   *  A---B---C       base
+   *    A---B---E---F extension              X---Y extension
+   *   /                                    /
+   *  A---B---C       base                 A---B   base
    *
    *      ||  upgrade extension with base - migration version C is inserted into extension, its version number is updated,
    *      ||  its version number is rebased on the version number of the extension
    *      \/
    *
-   *    A---B---E---F---C extension
-   *   /
-   *  A---B---C           base
+   *    A---B---E---F---C extension          A---B---X---Y extension
+   *   /                                    /
+   *  A---B---C           base             A---B           base
    *
    * @param {MigrationTableModel} base The new base migration table version from which all missing migration versions
    * will be taken and merged into the new migration table result.
@@ -230,17 +229,18 @@ class MigrationTableModel {
    * retrieved from the migration table file created by cds build based on the final CDS model version.
    * @returns {MigrationTableModel} The merge result containg missing migrations from base.
    */
-  merge(base, targetTable) {
-    let idxMaster = base.migrations.entries.findIndex(baseMigration => {
-      return this.migrations.entries.some(extensionMigration => this._compareMigrations(extensionMigration, baseMigration))
-    })
+  merge(base, targetTable, addBaseVersionAnnotation) {
+    let idxBase = this._findCommonBaseMigrationIdx(base)
     const mergeResult = new MigrationTableModel(targetTable, this.migrations.clone())
-    // insert all migration versions of master
-    for (let idx = idxMaster === - 1 ? base.migrations.entries.length - 1 : idxMaster - 1; idx >= 0; idx--) {
+
+    // insert all migration versions since the histories diverged
+    for (let idx = idxBase >= 0 ? idxBase - 1 : base.migrations.entries.length - 1, versionNumber = this.versionNumber + 1; idx >= 0; idx--, versionNumber++) {
       const migration = base.migrations.entries[idx].clone();
+      if (addBaseVersionAnnotation) {
+        migration._addBaseMigrationVersion(migration.versionNumber)
+      }
       // update migration version number and insert at beginning
-      migration.versionNumber = this.versionNumber + 1
-      mergeResult.table.versionNumber = this.versionNumber + 1
+      migration.versionNumber = mergeResult.table.versionNumber = versionNumber
       mergeResult.migrations.entries.splice(0, 0, migration)
     }
     return mergeResult
@@ -250,13 +250,63 @@ class MigrationTableModel {
     return new MigrationTableModel(this.table.clone(), this.migrations.clone())
   }
 
-  // migrations are identical if the underlying changesets are identical
-  _compareMigrations(migration1, migration2) {
-    return this._compactStr(migration1.changeset) === this._compactStr(migration2.changeset)
+  /**
+   * Returns the index of the common base migration version (since the time their histories diverged)
+   * or -1 if there is no common base. The index points to the base migration table model.
+   * @param {MigrationTableModel} base The new base migration table version.
+   * @returns The index of the common base migration, -1 if there is no common base.
+   */
+  _findCommonBaseMigrationIdx(base) {
+    // get the index based on the annotation '-- migration-base=<version number>'
+    const extMigration = this.migrations.entries.find(extMigration => extMigration._getBaseMigrationVersion() !== -1)
+    // get the index based on DDL equality
+    const idxBase = base.migrations.entries.findIndex(baseMigration => {
+      return this.migrations.entries.some(extMigration => this._compareMigrations(baseMigration, extMigration))
+    })
+    if (!extMigration && idxBase === -1) {
+      // no common base version - all good
+      return -1
+    }
+    if (extMigration && idxBase !== -1 && extMigration._getBaseMigrationVersion() === base.migrations.entries[idxBase].versionNumber) {
+      // both indices refer to the same base version - all good
+      return idxBase
+    }
+    // differences encountered, cause might be:
+    // 1. older versions may not add 'migration-base' annotations
+    // 2. the same DDL statements might exist in different migrations
+    if (!extMigration && idxBase !== -1) {
+      // if migration-base annotations do not exist use equality of DDL statements
+      // older versions did not add 'migration-base' annotations - most probably all good
+      return idxBase
+    }
+    if (extMigration) {
+      // favor 'migration-base' annotation over DDL statement equality
+      const baseVersion = extMigration._getBaseMigrationVersion()
+      const idxBase = base.migrations.entries.findIndex(baseMigration => baseMigration.versionNumber === baseVersion)
+      if (idxBase > -1) {
+        return idxBase
+      }
+    }
+    return idxBase
+  }
+
+  /** 
+   * Migrations are identical if the corresponding DDL statements are identical,
+   * ignoring order and ignoring comments.
+   */
+  _compareMigrations(m1, m2) {
+    if (m1.ddl.length !== m2.ddl.length) {
+      return false
+    }
+    const mDdl2 = m2.ddl.map(entry => this._compactLine(entry))
+    return m1.ddl.some(entry => mDdl2.includes(this._compactLine(entry)))
   }
 
-  _compactStr(array) {
-    return JSON.stringify(array.map(change => change.replace(/ /g, '')))
+  /**
+   * Delete comments and return only those lines representing DDL statements.
+   */
+  _compactLine(line) {
+    return line.replace(/ /g, '')
   }
 }
 
@@ -349,7 +399,6 @@ class Migration {
       this._lines = lines
     }
     this._versionNumber = MigrationTableParser._parseVersionNumber(this.lines[0])
-    this._changeset = this._lines.filter(line => !MigrationTableParser._isMigrationMarker(line))
   }
 
   /**
@@ -378,7 +427,7 @@ class Migration {
    * Returns the changeset containing the DDL statements of this migration.
    */
   get changeset() {
-    return this._changeset
+    return this._lines.filter(line => !MigrationTableParser._isMigrationMarker(line))
   }
 
   /**
@@ -389,6 +438,25 @@ class Migration {
     return this.changeset.filter(line => MigrationTableParser._isDDL(line))
   }
 
+  _addBaseMigrationVersion(versionNumber) {
+    this._addComment(1, `-- migration-base=${versionNumber}`)
+  }
+
+  _getBaseMigrationVersion() {
+    let versionNumber = -1
+    if (this._lines.length > 1) {
+      const match = this._lines[1].match(/(^\s*-- migration-base=)(\d+)\s*$/)
+      if (match && match.length === 3) {
+        versionNumber = parseInt(match[2])
+      }
+    }
+    return versionNumber
+  }
+
+  _addComment(start, comment) {
+    this._lines.splice(start, 0, comment)
+  }
+
   /**
    * Returns the string representation of this migration.
    */

package/bin/build/provider/hana/template/undeploy.json

@@ -0,0 +1,5 @@
+[
+    "src/gen/**/*.hdbview",
+    "src/gen/**/*.hdbindex",
+    "src/gen/**/*.hdbconstraint"
+]

package/bin/build/provider/node-cf/index.js

@@ -4,7 +4,10 @@ const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
 const { getHanaDbModuleDescriptor, getServiceModuleDescriptor } = require('../../mtaUtil')
 const { BuildError } = require('../../util')
 const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, ODATA_VERSION, ODATA_VERSION_V2,
-    BUILD_TASK_HANA, FOLDER_GEN, BUILD_NODEJS_EDMX_GENERAION, EDMX_GENERATION, SKIP_PACKAGE_JSON_GENERATION, SKIP_MANIFEST_GENERATION, CONTENT_EDMX, CONTENT_MANIFEST, CONTENT_PACKAGE_JSON } = require('../../constants')
+    BUILD_TASK_HANA, FOLDER_GEN, BUILD_NODEJS_EDMX_GENERAION, EDMX_GENERATION,
+    SKIP_PACKAGE_JSON_GENERATION, SKIP_MANIFEST_GENERATION,
+    CONTENT_EDMX, CONTENT_MANIFEST, CONTENT_PACKAGE_JSON, CONTENT_PACKAGELOCK_JSON  }
+    = require('../../constants')
 const { WARNING } = require('../../buildTaskHandler')
 
 const FILE_NAME_MANIFEST_YML = "manifest.yml"
@@ -16,6 +19,7 @@ class NodeCfModuleBuilder extends BuildTaskHandlerEdmx {
         this.task.options[CONTENT_EDMX] = this.hasBuildOption(CONTENT_EDMX, true) || this.hasCdsEnvOption(BUILD_NODEJS_EDMX_GENERAION, true) || this.hasBuildOption(EDMX_GENERATION, true) ? true : false
         this.task.options[CONTENT_MANIFEST] = !this.hasBuildOption(CONTENT_MANIFEST, false) && !this.hasBuildOption(SKIP_MANIFEST_GENERATION, true) ? true : false
         this.task.options[CONTENT_PACKAGE_JSON] = !this.hasBuildOption(CONTENT_PACKAGE_JSON, false) && !this.hasBuildOption(SKIP_PACKAGE_JSON_GENERATION, true) ? true : false
+        this.task.options[CONTENT_PACKAGELOCK_JSON] = !this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, false) ? true : false
 
         if (this.task.options.compileDest) {
             throw new BuildError("Option not supported - compileDest")
@@ -66,7 +70,7 @@ class NodeCfModuleBuilder extends BuildTaskHandlerEdmx {
     }
 
     async _copyNativeContent(src, dest) {
-        const regex = RegExp('\\.cds$|package\\.json|manifest\\.y.?ml')
+        const regex = RegExp('\\.cds$|package\\.json|package-lock\\.json|manifest\\.y.?ml')
 
         await super.copyNativeContent(src, dest, (entry) => {
             if (fs.statSync(entry).isDirectory()) {
@@ -92,6 +96,9 @@ class NodeCfModuleBuilder extends BuildTaskHandlerEdmx {
                 packageJsonCopy = true
                 return true
             }
+            if (/package-lock\.json$/.test(entry) && this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, true)) {
+                return true
+            }
             return false
         })
 

package/bin/serve.js

@@ -124,7 +124,7 @@ module.exports = Object.assign ( serve, {
 
 
 const cds = require('../lib'), { exists, isfile, local, path } = cds.utils
-let log = console.log // provisional logger, see _prepareLogging
+let log = console.log // provisional logger, see _prepare_logging
 
 /**
  * The main function which dispatches into the respective usage variants.
@@ -139,7 +139,7 @@ async function serve (all=[], o={}) { // NOSONAR
   else if (o.service)        { o.from    = pms ? pms.split(',') : '*'}
   else if (o.from)           { o.service = pms }
   else if (exists(pms))      { o.service ='all', o.from = all }
-  else                       { o.service = pms,  o.from = '*' }
+  else                       { o.service = pms||'all',  o.from = '*' }
 
   // IMPORTANT: never load any @sap/cds modules before the chdir above happened!
   // handle --watch and --project
@@ -151,16 +151,16 @@ async function serve (all=[], o={}) { // NOSONAR
   const {features} = cds.env
   {
     // handle --with-mocks resp. --mocked
-    if (!features.no_mocking) o.mocked = _with_mocks (o)
+    if (features.with_mocks) o.mocked = _with_mocks(o)
 
     // handle --in-memory resp. --in-memory?
-    if (features.in_memory_db) o.in_memory = _in_memory (o)
+    if (features.in_memory_db) o.in_memory = _in_memory(o)
 
     // load service bindings when mocking or asked to
     if (features.mocked_bindings && o.mocked || o['with-bindings']) await cds.service.bindings
 
     // live reload, in cooperation with cds watch
-    if (features.live_reload)  require('../app/etc/livereload')
+    if (features.live_reload) require('../app/etc/livereload')
 
     // add dev helper for Fiori URLs
     if (features.fiori_routes) require('../app/fiori/routes')
@@ -203,38 +203,37 @@ function _prepare_logging () { // NOSONAR
   // change `log` function to cds.log
   const LOG = cds.log('serve', { prefix:'cds' })
   log = LOG._info && LOG.info
+  if (!log) return
 
-  const _timer = log && `[cds] - launched at ${new Date().toLocaleString()}, in`
-  _timer && console.time (_timer)
+  const _timer = `[cds] - launched at ${new Date().toLocaleString()}, in`
+  console.time (_timer)
 
   // print information when model is loaded
   cds.on ('loaded', (model)=>{
-    log && log (`model loaded from ${model.$sources.length} file(s):\n\x1b[2m`)
-    for (let each of model.$sources)  log && console.log (' ', local(each))
-    log && console.log ('\x1b[0m')
+    log (`model loaded from ${model.$sources.length} file(s):\n\x1b[2m`)
+    for (let each of model.$sources)  console.log (' ', local(each))
+    console.log ('\x1b[0m')
   })
 
   // print information about each connected service
   cds.on ('connect', ({name,kind,options:{use,credentials}})=>{
-    log && log (`connect to ${name} > ${use||kind}`, credentials ? _redacted(credentials) : '')
+    log (`connect to ${name} > ${use||kind}`, credentials ? _redacted(credentials) : '')
   })
 
   // print information about each provided service
   cds.on ('serving', (srv) => {
     const details = { at: srv.path }
     if (srv._source) details.impl = local(srv._source)
-    log && log (`${srv.mocked ? 'mocking' : 'serving'} ${srv.name}`, details)
+    log (`${srv.mocked ? 'mocking' : 'serving'} ${srv.name}`, details)
   })
 
   // print info when we are finally on air
   cds.once ('listening', ({url})=>{
-    log && console.log ()
-    log && log ('server listening on',{url})
+    console.log ()
+    log ('server listening on',{url})
     _timer && console.timeEnd (_timer)
-    if (process.stdin.isTTY) log && log (`[ terminate with ^C ]\n`)
+    if (process.stdin.isTTY) log (`[ terminate with ^C ]\n`)
   })
-
-  return cds
 }
 
 
@@ -275,7 +274,6 @@ function _in_memory (o) {
 
 /** handles --with-mocks option */
 function _with_mocks (o) {
-  if (process.env.NODE_ENV === 'production') return
   if (o.mocked || (o.mocked = o['with-mocks'])) {
     cds.on ('loaded', model => cds.deploy.include_external_entities_in(model))
     const mocks = cds.env.features.test_mocks && isfile ('test/mocked.js')

package/lib/compile/cdsc.js

@@ -1,9 +1,19 @@
-const {cdsc,odata,sql,hana} = require ('../index').env
+const {cdsc,odata,sql,hana,features} = require ('../index').env
+const constraints = {
+  assertIntegrity: features.assert_integrity,
+  assertIntegrityType: features.assert_integrity_type
+}
+// REVISIT: remove with compiler ^2.11
+const { assertIntegrity: ai, assertIntegrityType: ait } = constraints
+if ((typeof ai === 'string' && ai.match(/individual/i)) || (ait && ait.match(/db/i))) {
+  cdsc.beta = cdsc.beta || {}
+  cdsc.beta.foreignKeyConstraints = true
+}
 const compile = require ('@sap/cds-compiler')
 const _4cdsc = Symbol('_4cdsc')
 
 /**
- * Returns a copy of the given options object, which all mappings applied and
+ * Returns a copy of the given options object, with all mappings applied and
  * finally overridden with entries from cds.env.cdsc. That is, the equivalent
  * of {...o, ...[...mappings], ...cds.env.cdsc }.
  * @type <T> (src:T,...mappings:{}[]) => T
@@ -11,7 +21,7 @@ const _4cdsc = Symbol('_4cdsc')
 function _options4 (src, ...mappings) {
   if (src[_4cdsc]) return src //> already prepared for cdsc
   // Create a derivate of given src options object
-  const dst = Object.defineProperty({__proto__:src},_4cdsc,{value:true}) // NOTE: {__proto__:src} not possible due to compiler obviously cloning options
+  const dst = Object.defineProperty({__proto__:src, ...src}, _4cdsc,{value:true}) // NOTE: {__proto__:src} alone doesn't suffice, due to compiler obviously cloning options; {...src} doesn't suffice as non-enumerables from .effective.odata would get lost
   // Apply mappings in order of appearance -> latter ones override formers
   for (let map of mappings) for (let k in map) {
     let v = dst[k];  if (v === undefined) continue
@@ -61,10 +71,10 @@ const _options = {for: Object.assign (_options4, {
   },
 
   sql(o,_env) {
-    return _options4 ({ ..._env||sql, ...o }, {
+    return _options4 ({ ...constraints, ..._env||sql, ...o }, {
       sql_mapping  : 'names', //> legacy
       sqlDialect   : 'dialect', //> legacy
-      sqlMapping  : 'names',
+      sqlMapping   : 'names',
       dialect      : 'sqlDialect',
       names        : (o,v) => v !== 'plain' ? o.sqlMapping = v : undefined,
     })

package/lib/compile/etc/_localized.js

@@ -42,13 +42,13 @@ function unfold_csn (m) { // NOSONAR
 	// only do that once per model
 	if (!m || m[_been_here]) return m
 	// eslint-disable-next-line no-console
-	DEBUG && console.trace ('unfolding csn...')
+	DEBUG && DEBUG ('unfolding csn...')
 	const pass2 = []
 
 	const _locales = _on_sqlite && _locales_4sql.sqlite
 
 	// Pass 1 - add localized.<locale> entities and views
-	for (let each in m.definitions) {
+	for (let each in cds.linked(m).definitions) {
 		const d = m.definitions [each]
 		// Add <entry>_texts proxies for all <entry>.texts entities
 		if (_texts_entries !== false && each.endsWith('.texts')) {
@@ -99,5 +99,5 @@ function unfold_csn (m) { // NOSONAR
 
 
 // feature-toggled exports
-module.exports = Object.assign ( unfold_csn, { unfold_ddl })
-if (!env.features.localized) module.exports = Object.assign ( x=>x, { unfold_ddl: x=>x })
+module.exports = { unfold_csn, unfold_ddl }
+if (!env.features.localized) Object.assign (module.exports, { unfold_csn: x=>x, unfold_ddl: x=>x })

package/lib/compile/extend.js

@@ -0,0 +1,8 @@
+const { extend } = require ('../lazy')
+const compile = require ('./index')
+
+module.exports = o => o.definitions ? { with(...exts) {
+  const all = { 'base.csn': JSON.stringify(o) }
+  exts.forEach ((x,i)=> all[i+'.csn'] = JSON.stringify(x))
+  return compile (all)
+}} : extend(o)

package/lib/compile/index.js

@@ -16,6 +16,7 @@ const compile = module.exports = Object.assign (cds_compile, {
   to: lazified ({
     csn: cds_compile,
     cdl: require('./to/cdl'),
+    gql: require('./to/gql'),
     yml: require('./to/yaml'),
     yaml: require('./to/yaml'),
     json: require('./to/json'),
@@ -26,6 +27,7 @@ const compile = module.exports = Object.assign (cds_compile, {
     serviceinfo: require('./to/srvinfo'), //> REVISIT: move to CLI
   }),
 
+  _localized: require('./etc/_localized'),
 })
 
 
@@ -53,7 +55,7 @@ function cds_compile (model, options, _flavor) {
   }
   else return _fluent (_finalize (cdsc.compileSources(model,o)))              //> compile CDL sources
   function _finalize (csn) {
-    if (o.min) csn = cds.linked(csn).minified()
+    if (o.min) csn = cds.minify(csn)
     // REVISIT: experimental implementation to detect external APIs
     for (let each in csn.definitions) {
       const d = csn.definitions[each]

package/lib/compile/minify.js

@@ -0,0 +1,61 @@
+module.exports = function cds_minify (csn, _roots = global.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') {
+    for (let n in all) if (all[n].kind === 'service') _visit_service(n)
+  } 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)
+    else if (d.kind === 'entity') {
+      if (d['@cds.persistence.skip'] === 'if-unused') continue
+      if (n.endsWith('.texts')) {
+        let e = all[n.slice(0,-6)]
+        if (e && e['@cds.persistence.skip'] === 'if-unused') continue
+      }
+      _visit(d)
+    }
+  }
+  function _visit_service (service) {
+    reached.add (all[service])
+    for (let e in all) if (e.startsWith(service+'.')) _visit(all[e])
+  }
+  function _visit_query (q) {
+    if (q.SELECT) return _visit_query (q.SELECT)
+    if (q.SET) return q.SET.args.forEach (_visit_query)
+    if (q.from) {
+      if (q.from.join) return q.from.args.forEach (_visit)
+      else return _visit (q.from)
+    }
+  }
+  function _visit (d) {
+    if (typeof d === 'string') {
+      if (d.startsWith('cds.')) return
+      else d = all[d]
+    } else if (d.ref) return d.ref.reduce((p,n) => {
+      let d = p.elements[n.id || n] // > n.id -> view with parameters
+      _visit(d)
+      return d
+    },{elements:all})
+    if (reached.has(d)) return; else reached.add(d)
+    if (d.includes)   d.includes.forEach(i => _visit(all[i]))  // Note: with delete d.includes, redirects in AFC broke
+    if (d.projection)         _visit_query (d.projection)
+    if (d.query)              _visit_query (d.query)
+    if (d.type)               _visit (d.type)
+    if (d.target)             _visit (d.target)
+    if (d.targetAspect)       _visit (d.targetAspect)
+    if (d.items)              _visit (d.items)
+    if (d.returns)            _visit (d.returns)
+    for (let e in d.elements) _visit (d.elements[e])
+    for (let a in d.actions)  _visit (d.actions[a])
+    for (let p in d.params)   _visit (d.params[p])
+  }
+  const minified = Object.create (csn.__proto__, Object.getOwnPropertyDescriptors(csn))
+  const less = minified.definitions = {}
+  for (let n in all) if (reached.has(all[n])) less[n] = all[n]
+  return minified
+}
+
+const _minified = Symbol('minified')

package/lib/compile/resolve.js

@@ -23,9 +23,12 @@ module.exports = exports = function cds_resolve (model, o={}) { // NOSONAR
 
   const cwd = o.root || global.cds && global.cds.root, local = resolve (cwd,model)
   const context = _paths(cwd), {cached} = context
-  const id = model.startsWith('.') ? local : model
+  let id = model.startsWith('.') ? local : model
   if (id in cached && !o.skipModelCache)  return cached[id]
 
+  // expand @sap/cds by cds.home
+  if (id.startsWith('@sap/cds')) id = global.cds.home +'/'+ id.slice(8)
+
   // fetch file with .cds/.csn suffix as is
   if (/\.(csn|cds)$/.test(id)) try {
     return cached[id] = _resolved ([ _resolve (id,context) ])

package/lib/compile/to/gql.js

@@ -0,0 +1,9 @@
+const { generate } = require ('../../../libx/gql/schema')
+const cds = require ('../..')
+
+function cds_compile_to_gql (csn) {
+  const m = cds.linked(csn)
+  return generate (m.services.map(s => ({ name:s.name, model:m })))
+}
+
+module.exports = cds_compile_to_gql

package/lib/compile/to/sql.js

@@ -1,47 +1,25 @@
-const cds = require ('../..'), minified = csn => cds.linked(csn).minified()
+const cds = require ('../..'), { unfold_ddl: cds_localized } = cds.compile._localized
 const cdsc = require ('../cdsc')
-const {unfold_ddl} = cds.alpha_localized
-const EXT_BACK_PACK = 'extensions__'
 
-function cds_compile_to_sql_ (csn,_o) {
+
+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 (minified(csn),o)
-  const sql = unfold_ddl (all.map (each => each
-    .replace(/^-- .+\n/,'')  //> strip comments
-  ), csn, o)
+  const all = cdsc.to.sql(csn,o) .map (each => each.replace(/^-- .+\n/,''))  //> strip comments
+  const sql = cds_localized(all, csn, o)
   if (o.as === 'str') return `\n${sql.join('\n\n')}\n`
   return sql
 }
 
-function cds_compile_to_sql (csn,_o) {
-  const defs = cds.linked(csn).definitions
-  for (let each in defs) {
-    const d = defs[each], q = d.query
-    // q may have SET instead of SELECT
-    if (q && q.SELECT && q.SELECT.columns && _is_extensible(d)) _add_extensions2 (q.SELECT.columns)
-  }
-  function _is_extensible (d) {
-    if(!d || !d.elements) return false
-    if (EXT_BACK_PACK in d.elements) return true
-    else return _is_extensible (d.__proto__)
-  }
-  function _add_extensions2 (cols) {
-    if (cols.some(({ref}) => ref && ref[0] === EXT_BACK_PACK)) return
-    cols.push({ref:[EXT_BACK_PACK]})
-  }
-  const ddl = cds_compile_to_sql_ (csn,_o)
-  return ddl
-}
-
 
 function cds_compile_to_hdbtable (csn,o) {
-  const all = cdsc.to.hdi (minified(csn),o)
+  const all = cdsc.to.hdi (cds.minify(csn),o)
   return _2many(all)
 }
 
 
 function cds_compile_to_hdbcds (csn,o) {
-  const all = cdsc.to.hdbcds (minified(csn),o)
+  const all = cdsc.to.hdbcds (cds.minify(csn),o)
   const constructFileName = (fileName) => {
     const identifier = fileName.split('.');
     const suffix = identifier.pop();
@@ -61,3 +39,21 @@ module.exports = Object.assign (cds_compile_to_sql, {
   hdbcds: cds_compile_to_hdbcds,
   hdbtable: cds_compile_to_hdbtable,
 })
+
+
+
+/////////////////////////////////////////////////////////////////////////////
+// UI Flex - read extensions__ to views, when ext fields are read
+const _extended = (csn) => {
+  const defs = cds.linked(csn).definitions
+  for (let each in defs) {
+    const d = defs[each], q = d.query // TODO: q may have SET instead of SELECT
+    if (q && q.SELECT && q.SELECT.columns && _is_extensible(d)) {
+      if (!q.SELECT.columns.some(({ref}) => ref && ref[0] === _extensions)) q.SELECT.columns.push({ref:[_extensions]})
+    }
+  }
+  return csn
+}
+const _is_extensible = d => _extensions in d.elements || d.__proto__.elements && _is_extensible (d.__proto__)
+const _extensions = 'extensions__'
+/////////////////////////////////////////////////////////////////////////////

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 (`No service definition found for '${required.service || datasource}', as required by 'cds.requires.${datasource}':`, required)
+    LOG._error && 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

@@ -11,9 +11,6 @@ class entity extends struct   {
   get compositions() {
     return this.own('_compositions') || this.set('_compositions', this._elements (e => e instanceof Composition))
   }
-  get texts() {
-    return this.own('_texts') || this.set('_texts', {__proto__:this, name: this.name + '.texts' })
-  }
   get drafts() {
     return this.own('_drafts') || this.set('_drafts',
       this.elements.HasDraftEntity && { name: this.name + '_drafts', keys: this.keys }

package/lib/core/infer.js

@@ -14,6 +14,7 @@ module.exports = (q,defs) => {
 
 const _resolve = (from, defs) => {
   if (!from || from.name) return from
+  while (from.SELECT) from = from.SELECT.from
   if (from.join || from.set) return //_unresolved()
   if (from.ref) {
     if (from.ref.length === 1) {