@sap/cds 7.6.4 → 7.7.1

package/lib/dbs/cds-deploy.js

@@ -1,73 +1,61 @@
 #!/usr/bin/env node
-const cds = require('../index'), { local } = cds.utils
-const crypto = require('crypto')
-const COLORS = !!process.stdout.isTTY && !!process.stderr.isTTY && !process.env.NO_COLOR
-const GREY = COLORS ? '\x1b[2m' : ''
-const RESET = COLORS ? '\x1b[0m' : ''
+const cds = require('../index'), { local, path } = cds.utils
 const DEBUG = cds.debug('deploy')
+const TRACE = cds.debug('trace')
+
+
+/** Fluent API: cds.deploy(model).to(db) */
+const deploy = module.exports = function cds_deploy (model, options, csvs) {
+  return { async to (/** @type {import('../../lib/srv/srv-api')} */ db, o = options||{}) {
+
+    // prepare logging
+    const [ GREY, RESET ] = !!process.stdout.isTTY && !!process.stderr.isTTY && !process.env.NO_COLOR ? ['\x1b[2m', '\x1b[0m' ] : ['','']
+    const LOG = !o.silent && !o.dry && cds.log('deploy')._info ? console.log : undefined
+
+    // prepare model
+    if (!model) throw new Error('Must provide a model or a path to model, received: ' + model)
+    if (!model?.definitions) model = await cds.load(model).then(cds.minify)
+    if (o.mocked) deploy.include_external_entities_in(model)
+    else deploy.exclude_external_entities_in(model)
+
+    // prepare db
+    if (!db.run) db = await cds.connect.to(db)
+    if (!cds.db) cds.db = cds.services.db = db
+    if (!db.model) db.model = model // NOTE: this calls compile.for.nodejs! Has to happen here for db/init.js to access cds.entities
+    // NOTE: This ^^^^^^^^^^^^^^^^^ is to support tests that use cds.deploy() to bootstrap a functional db like so:
+    // const db = await cds.deploy ('<filename>') .to ('sqlite::memory:')
+
+    // prepare db description for log output below
+    let descr = db.url4 (cds.context?.tenant)
+    if (descr === ':memory:') descr = 'in-memory database.'
+    else if (!descr.startsWith('http:')) descr = local (descr)
+
+    // deploy schema and initial data...
+    try {
+      const _run = fn => o.dry ? fn(db) : db.run(fn)
+      await _run (async tx => {
+        let any = await deploy.schema (tx, model, o)
+        if (any || csvs) await deploy.data (tx, model, o, csvs, file => LOG?.(GREY, ' > init from', local(file), RESET))
+      })
+      LOG?.('/> successfully deployed to', descr, '\n')
+    } catch (e) {
+      LOG?.('/> deployment to', descr, 'failed\n')
+      throw e
+    }
+    return db
+  },
 
-/**
- * Implementation of `cds.deploy` common to all databases.
- * It uses the database-specific `db.deploy` to prepare the database, e.g.
- * deploy create tables and views in case of a SQL database, then fills
- * in initial data, if present.
- */
-module.exports = exports = function cds_deploy (model,options,csvs) {
-  return {
-    /** @param {import('@sap/cds/lib/srv/srv-api')} db */
-    async to(db, o = options || {}) {
-
-      const TRACE = cds.debug('trace')
-      TRACE?.time('cds.deploy db  ')
-
-      if (!model) throw new Error('Must provide a model or a path to model, received: ' + model)
-      if (!model?.definitions) model = await cds.load(model).then(cds.minify)
-
-      if (o.mocked) exports.include_external_entities_in(model)
-      else exports.exclude_external_entities_in(model)
-
-      if (!db.run) db = await cds.connect.to(db)
-      if (!cds.db) cds.db = cds.services.db = db
-      if (!db.model) db.model = model // NOTE: this calls compile.for.nodejs!
-
-      // eslint-disable-next-line no-console
-      const LOG = o.silent || o.dry || !cds.log('deploy')._info ? () => {} : console.log
-      const _deploy = async tx => {
-        // create / update schema
-        let any = await exports.create(tx, model, o)
-        if (!any && !csvs) return db
-        // fill in initial data
-        await exports.init(tx, model, o, csvs, file => LOG(GREY, ` > init from ${local(file)}`, RESET))
-      }
-
-      let url = db.url4(cds.context?.tenant)
-      if (url === ':memory:') url = 'in-memory database.'
-      else if (!url.startsWith('http:')) url = local(url)
-      try {
-        await (o.dry ? _deploy(db) : db.run(_deploy))
-        LOG('/> successfully deployed to', url, '\n')
-      } catch (e) {
-        LOG('/> deployment to', url, 'failed\n')
-        throw e
-      }
-
-      TRACE?.timeEnd('cds.deploy db  ')
-      return db
-    },
-
-    // continue to support cds.deploy() as well...
-    then(n, e) {
-      return this.to(cds.db || 'db').then(n, e)
-    },
-    catch(e) {
-      return this.to(cds.db || 'db').catch(e)
-    },
-  }
-}
-
-exports.create = async function cds_deploy_create (db, csn=db.model, o) {
+  // Also support await cds.deploy()...
+  then(n, e) {
+    return this.to(cds.db || cds.requires.db && 'db' || 'sqlite::memory:').then(n,e)
+  },
+  catch(e) {
+    return this.to(cds.db || cds.requires.db && 'db' || 'sqlite::memory:').catch(e)
+  },
+}}
 
-  /* eslint-disable no-console */
+/** Deploy database schema, i.e., generate and apply SQL DDL. */
+deploy.schema = async function (db, csn = db.model, o) {
 
   if (!o.to || o.to === db.options.kind)  o = { ...db.options, ...o }
   if (o.impl === '@cap-js/sqlite') {
@@ -102,6 +90,8 @@ exports.create = async function cds_deploy_create (db, csn=db.model, o) {
     creas = cds.compile.to.sql(csn,o) // NOTE: this used to call cds.linked(cds.minify) and thereby corrupted the passed in csn
   }
 
+  TRACE?.time('cds.deploy schema'.padEnd(22))
+
   if (!drops) {
     drops = [];
     creas.forEach(each => {
@@ -118,21 +108,21 @@ exports.create = async function cds_deploy_create (db, csn=db.model, o) {
   if (!drops.length && !creas.length) return !o.dry
 
   if (o.dry) {
-    console.log()
-    for (let each of drops) console.log(each)
-    console.log()
-    for (let each of creas) console.log(each, '\n')
+    console.log(); for (let each of drops) console.log(each)
+    console.log(); for (let each of creas) console.log(each, '\n')
     return
   }
 
   await db.run(drops)
   await db.run(creas)
+
+  TRACE?.timeEnd('cds.deploy schema'.padEnd(22))
   return true
 
   async function get_prior_model() {
     let file = o['delta-from']
     if (file) {
-      let prior = await cds.utils.read(file)
+      let prior = await cds.utils.read (file)
       return { prior: typeof prior === 'string' ? JSON.parse(prior) : prior }
     }
     if (o.dry) return {}
@@ -155,57 +145,17 @@ exports.create = async function cds_deploy_create (db, csn=db.model, o) {
 }
 
 
-const { fs, path, read } = cds.utils
-const { readdir } = fs.promises
-const isdir = (..._) => fs.isdir(path.join(..._))
-const isfile = (..._) => fs.isfile(path.join(..._))
+/** Deploy initial data */
+deploy.data = async function (db, csn = db.model, o, srces, log=()=>{}) {
 
-exports.include_external_entities_in = function (model) {
-  if (model._mocked) return model; else Object.defineProperty(model,'_mocked',{value:true})
-  for (let each in model.definitions) {
-    const def = model.definitions[each]
-    if (def['@cds.persistence.mock'] === false) continue
-    if (def['@cds.persistence.skip'] === true) {
-      DEBUG?.('including mocked', each)
-      delete def['@cds.persistence.skip']
-    }
-  }
-  exports.exclude_external_entities_in (model)
-  return model
-}
-
-exports.exclude_external_entities_in = function (csn) { // NOSONAR
-  // IMPORTANT to use cds.env.requires below, not cds.requires !!
-  for (let [each,{service=each,model,credentials}] of Object.entries (cds.env.requires)) {
-    if (!model) continue //> not for internal services like cds.requires.odata
-    if (!credentials && csn._mocked) continue //> not for mocked unbound services
-    DEBUG?.('excluding external entities for', service, '...')
-    const prefix = service+'.'
-    for (let each in csn.definitions) if (each.startsWith(prefix)) _exclude (each)
-  }
-  return csn
-
-  function _exclude (each) {
-    const def = csn.definitions[each]; if (def.kind !== 'entity') return
-    if (def['@cds.persistence.table'] === true) return // do not exclude replica table
-    DEBUG?.('excluding external entity', each)
-    def['@cds.persistence.skip'] = true
-    // propagate to all views on top...
-    for (let other in csn.definitions) {
-      const d = csn.definitions[other]
-      const p = d.query && d.query.SELECT || d.projection
-      if (p && p.from.ref && p.from.ref[0] === each) _exclude (other)
-    }
-  }
-}
-
-
-exports.init = async function cds_deploy_init (db, csn=db.model, o, srces, log=()=>{}) {
   const t = cds.context?.tenant; if (t && t === cds.requires.multitenancy?.t0) return
+  const crypto = require('crypto')
+
   return db.run (async tx => {
+    TRACE?.time('cds.deploy data'.padEnd(22))
 
     const m = tx.model = cds.compile.for.nodejs(csn) // NOTE: this used to create a redundant 4nodejs model for tha same csn
-    const data = await exports.data (m,srces)
+    const data = await deploy.prepare (m,srces)
     const query = _queries4 (db,m)
     const INSERT_from = INSERT_from4 (db,m,o)
 
@@ -214,18 +164,89 @@ exports.init = async function cds_deploy_init (db, csn=db.model, o, srces, log=(
       if (entity) {
         const q = INSERT_from (file) .into (entity, src)
         if (q) try { await tx.run (query(q)) } catch(e) {
-          throw Object.assign (e, { message: 'in cds.deploy(): ' + e.message +'\n'+ cds.utils.inspect(q) })
+          throw Object.assign (e, { message: 'in cds.deploy(): ' + e.message +'\n'+ cds.utils.inspect(q, {depth:11}) })
         }
       } else {  //> init.js/ts case
         if (typeof src === 'function') await src(tx,csn)
       }
     }
+
+    TRACE?.timeEnd('cds.deploy data'.padEnd(22))
   })
+
+
+  /** Prepare special handling for new db services */
+  function _queries4 (db, m) {
+    return !db.cqn2sql ? q => q : q => {
+      const { columns, rows } = q.INSERT || q.UPSERT; if (!columns) return q // REVISIT: .entries are covered by current runtime -> should eventually also be handled here
+      const entity = m.definitions[q._target.name]
+
+      // Fill in missing primary keys...
+      const { uuid } = cds.utils
+      for (let k in entity.keys) if (entity.keys[k].isUUID && !columns.includes(k)) {
+        columns.push(k)
+        rows.forEach(row => row.push(uuid()))
+      }
+
+      // Fill in missing managed data...
+      const pseudos = { $user: 'anonymous', $now: (new Date).toISOString() }
+      for (let k in entity.elements) {
+        const managed = entity.elements[k]['@cds.on.insert']?.['=']
+        if (managed && !columns.includes(k)) {
+          columns.push(k)
+          rows.forEach(row => row.push(pseudos[managed]))
+        }
+      }
+      return q
+    }
+  }
+
+  function INSERT_from4 (db,m,o) {
+    const schevo = o?.schema_evolution === 'auto' || db.options.schema_evolution === 'auto'
+    const INSERT_into = (schevo ? UPSERT : INSERT).into
+    return (file) => ({
+      '.json': { into (entity, json) {
+        let records = JSON.parse(json); if (!records.length) return
+        _add_ID_texts4 (entity, records)
+        return INSERT_into(entity).entries(records)
+      }},
+      '.csv': { into (entity, csv) {
+        let [cols, ...rows] = cds.parse.csv(csv); if (!rows.length) return
+        _add_ID_texts4 (entity, rows, cols)
+        return INSERT_into(entity).columns(cols).rows(rows)
+      }},
+    }) [path.extname(file)]
+  }
+
+  /**
+   * Fills in missing ID_texts for respective .texts entities.
+   * IMPORTANT: we use UUIDs generated from hashes of all original key values (ID, locale, ...)
+   * to ensure same ID_texts values for same keys across different deployments.
+   */
+  function _add_ID_texts4 (entity, records, cols) {
+    if (entity.name)  entity = entity.name  //> entity can be an entity name or a definition
+    if (!csn.definitions[entity]?.keys?.ID_texts) return // it's not a .texts entity with ID_texts key
+    if ((cols || Object.keys(records[0])).includes('ID_texts')) return // already there
+    else DEBUG?.(`adding ID_texts for ${entity}`)
+    const keys = Object.keys (csn.definitions[entity.slice(0,-6)].keys) .concat ('locale')
+    if (cols) {
+      cols.push ('ID_texts')
+      const indexes = keys.map (k => cols.indexOf(k))
+      for (let each of records) each.push (_uuid4(each,indexes))
+    } else {
+      for (let each of records) each.ID_texts = _uuid4(each,keys)
+    }
+    function _uuid4 (data, keys) {
+      const s = keys.reduce ((s,k) => s + data[k],'')
+      const h = crypto.createHash('md5').update(s).digest('hex')
+      return h.slice(0,8) + '-' + h.slice(8,12) + '-' + h.slice(12,16) + '-' + h.slice(16,20) + '-' + h.slice(20)
+    }
+  }
 }
 
 
 /** Prepare input from .csv, .json, init.js, ... */
-exports.data = async function cds_deploy_prepare_data (csn, srces) {
+deploy.prepare = async function (csn, srces) {
   // In case of extension deployment .csv or .json input are provided through argument `srces`.
   if (srces) return Object.entries(srces) .map (([file, src]) => {
     let e = _entity4 (path.basename(file,'.csv'), csn)
@@ -233,14 +254,14 @@ exports.data = async function cds_deploy_prepare_data (csn, srces) {
   })
   // If not, we load them from cds.deploy.resources(csn)
   const data = []
-  const resources = await exports.resources(csn, { testdata: cds.env.features.test_data })
+  const resources = await deploy.resources(csn, { testdata: cds.env.features.test_data })
   const resEntries = Object.entries(resources).reverse() // reversed $sources, relevant as UPSERT order
   for (const [file,e] of resEntries) {
     if (e === '*') {
       let init_js = await cds.utils._import (file)
       data.push([ file, null, init_js.default || init_js ])
     } else {
-      let src = await read (file, 'utf8')
+      let src = await cds.utils.read (file, 'utf8')
       data.push([ file, e, src ])
     }
   }
@@ -248,15 +269,17 @@ exports.data = async function cds_deploy_prepare_data (csn, srces) {
 }
 
 
-exports.resources = async function cds_deploy_resources (csn, opts) {
+/** Resolve initial data resources for given model */
+deploy.resources = async function (csn, opts) {
   if (!csn || !csn.definitions) csn = await cds.load (csn||'*') .then (cds.minify)
-  const folders = await cds_deploy_resources.folders(csn, opts)
+  const { fs, isdir, isfile } = cds.utils
+  const folders = await deploy.folders(csn, opts)
   const found={}, ts = process.env.CDS_TYPESCRIPT
   for (let folder of folders) {
     // fetching .csv and .json files
     for (let each of ['data','csv']) {
       const subdir = isdir(folder,each); if (!subdir) continue
-      const files = await readdir (subdir)
+      const files = await fs.promises.readdir (subdir)
       for (let fx of files) {
         if (fx[0] === '-') continue
         const ext = path.extname(fx); if (ext in {'.csv':1,'.json':2}) {
@@ -266,7 +289,7 @@ exports.resources = async function cds_deploy_resources (csn, opts) {
             DEBUG?.(`ignoring '${fx}' in favor of translated ones`)
             continue
           }
-          const e = _entity4(f,csn); if (_skip(e)) continue
+          const e = _entity4(f,csn); if (!e || e['@cds.persistence.skip'] === true) continue
           if (cds.env.features.deploy_data_onconflict === 'replace' && !/[._]texts_/.test(f)) {
             const seenBefore = Object.entries(found).find(([_, entity]) => entity === e.name )
             if (seenBefore) {
@@ -286,7 +309,8 @@ exports.resources = async function cds_deploy_resources (csn, opts) {
 }
 
 
-exports.resources.folders = async function (csn, o={}) {
+/** Resolve folders to fetch for initial data resources for given model */
+deploy.folders = async function (csn, o={}) {
   if (!csn || !csn.definitions) csn = await cds.load (csn||'*') .then (cds.minify)
   const folders = new Set (csn.$sources.map (path.dirname) .filter (f => f !== cds.home))
   if (cds.env.folders.db) folders.add (path.resolve(cds.root, cds.env.folders.db))
@@ -295,7 +319,51 @@ exports.resources.folders = async function (csn, o={}) {
 }
 
 
-const _entity4 = (file,csn) => {
+/** Include external entities in the given model */
+deploy.include_external_entities_in = function (csn) {
+  if (csn._mocked) return csn; else Object.defineProperty(csn,'_mocked',{value:true})
+  for (let each in csn.definitions) {
+    const def = csn.definitions[each]
+    if (def['@cds.persistence.mock'] === false) continue
+    if (def['@cds.persistence.skip'] === true) {
+      DEBUG?.('including mocked', each)
+      delete def['@cds.persistence.skip']
+    }
+  }
+  deploy.exclude_external_entities_in (csn)
+  return csn
+}
+
+/** Exclude external entities from the given model */
+deploy.exclude_external_entities_in = function (csn) {
+  // IMPORTANT to use cds.env.requires below, not cds.requires !!
+  for (let [each,{service=each,model,credentials}] of Object.entries (cds.env.requires)) {
+    if (!model) continue //> not for internal services like cds.requires.odata
+    if (!credentials && csn._mocked) continue //> not for mocked unbound services
+    DEBUG?.('excluding external entities for', service, '...')
+    const prefix = service+'.'
+    for (let each in csn.definitions) if (each.startsWith(prefix)) _exclude (each)
+  }
+  return csn
+
+  function _exclude (each) {
+    const def = csn.definitions[each]; if (def.kind !== 'entity') return
+    if (def['@cds.persistence.table'] === true) return // do not exclude replica table
+    DEBUG?.('excluding external entity', each)
+    def['@cds.persistence.skip'] = true
+    // propagate to all views on top...
+    for (let other in csn.definitions) {
+      const d = csn.definitions[other]
+      const p = d.query && d.query.SELECT || d.projection
+      if (p && p.from.ref && p.from.ref[0] === each) _exclude (other)
+    }
+  }
+
+}
+
+
+/** Helper for resolving entity for given .csv file */
+const _entity4 = (file, csn) => {
   const name = file.replace(/-/g,'.')
   const entity = csn.definitions [name]
   if (!entity) {
@@ -313,99 +381,8 @@ const _entity4 = (file,csn) => {
   return entity.name ? entity : { name, __proto__:entity }
 }
 
-
-/** Prepare special handling for new db services */
-const _queries4 = (db,csn) => !db.cqn2sql ? q => q : q => {
-  const { columns, rows } =  q.INSERT || q.UPSERT; if (!columns) return q // REVISIT: .entries are covered by current runtime -> should eventually also be handled here
-  const entity = csn.definitions[q._target.name]
-
-  // Fill in missing primary keys...
-  const { uuid } = cds.utils
-  for (let k in entity.keys) if (entity.keys[k].isUUID && !columns.includes(k)) {
-    columns.push(k)
-    rows.forEach(row => row.push(uuid()))
-  }
-
-  // Fill in missing managed data...
-  const pseudos = { $user: 'anonymous', $now: (new Date).toISOString() }
-  for (let k in entity.elements) {
-    const managed = entity.elements[k]['@cds.on.insert']?.['=']
-    if (managed && !columns.includes(k)) {
-      columns.push(k)
-      rows.forEach(row => row.push(pseudos[managed]))
-    }
-  }
-
-  return q
-}
-
-
-const INSERT_from4 = (db,m,o) => {
-  const schevo = o?.schema_evolution === 'auto' || db.options.schema_evolution === 'auto'
-  const INSERT_into = (schevo ? UPSERT : INSERT).into
-  return (file) => ({
-    '.json': { into (entity, json) {
-      let records = JSON.parse(json)
-      if (records.length > 0) {
-        fill_ID_texts_json(records, m, entity)
-        return INSERT_into(entity).entries(records)
-      }
-    }},
-    '.csv': { into (entity, csv) {
-      let [cols, ...rows] = cds.parse.csv(csv)
-      if (rows.length > 0) {
-        fill_ID_texts_csv(cols, rows, m, entity)
-        return INSERT_into(entity).columns(cols).rows(rows)
-      }
-    }},
-  }) [path.extname(file)]
-}
-
-const fill_ID_texts_json = (records, m, entity) => {
-  const baseKey = idTextsBaseKey(m, entity)
-  if (baseKey) {
-    records.forEach(record => {
-      if (!record.ID_texts) {
-        record.ID_texts = hashedUUID(record[baseKey], record.locale)
-      }
-    })
-  }
-}
-
-const fill_ID_texts_csv = (cols, rows, m, entity) => {
-  const baseKey = idTextsBaseKey(m, entity)
-  if (baseKey && !cols.find(r => r.toLowerCase() === 'id_texts')) { // and no such column in csv?
-    DEBUG?.(`adding ID_texts for ${entity}`)
-    const indexBaseKey = cols.findIndex(c => c.toLowerCase() === baseKey.toLowerCase())
-    const indexLocale = cols.findIndex(c => c.toLowerCase() === 'locale')
-    rows.forEach(row => {
-      const idtexts = hashedUUID(row[indexBaseKey], row[indexLocale])
-      row.push(idtexts)
-    })
-    cols.push('ID_texts')
-  }
-}
-
-const idTextsBaseKey = (m, entity) => {
-  let base
-  if (m.definitions[entity]?.keys?.ID_texts  // ID_text key?
-      && /(.+)[._]texts$/.test(entity) && (base = m.definitions[RegExp.$1])) { // in a .text entity?
-    const baseKey = Object.keys(base.keys)[0]  // base entity's key is usually, but not always 'ID'
-    return baseKey
-  }
-}
-
-const hashedUUID = (...values) => {
-  const sum = values.reduce((acc, curr) => acc + curr, '')
-  const h = crypto.createHash('md5').update(sum).digest('hex')
-  return h.slice(0, 8) + '-' + h.slice(8, 12) + '-' + h.slice(12, 16) + '-' + h.slice(16, 20) + '-' + h.slice(20)
-}
-
-const _skip = e => !e || e['@cds.persistence.skip'] === true
-
-
-
-if (!module.parent) (async () => {
+/** CLI used as via cds-deploy as deployer for PostgreSQL */
+if (!module.parent) (async function CLI () {
   await cds.plugins // IMPORTANT: that has to go before any call to cds.env, like through cds.deploy or cds.requires below
   let db = cds.requires.db
   try {

package/lib/env/defaults.js

@@ -1,4 +1,3 @@
-const { join } = require('path')
 const production = process.env.NODE_ENV === 'production'
 
 const defaults = module.exports = {
@@ -43,6 +42,8 @@ const defaults = module.exports = {
     routes: !production,
     lean_draft: true,
     wrap_multiple_errors: true, // switch default with cds 8
+    draft_lock_timeout: true,
+    draft_deletion_timeout: false, // switch default with cds 8
     draft_compat: undefined,
     '[better-sqlite]': { lean_draft: true },
     '[lean-draft]': { lean_draft: true },

package/lib/index.js

@@ -99,7 +99,7 @@ const cds = module.exports = global.cds = new class cds extends EventEmitter {
   get debug() { return super.debug = this.log.debug }
   get lazify() { return lazify }
   get lazified() { return lazify }
-  get clone() { return super.clone = this.utils.clone }
+  clone(x) { return structuredClone(x) }
   exit(code){ return cds.shutdown ? cds.shutdown() : process.exit(code) }
 
   // Querying and Databases
@@ -140,4 +140,10 @@ extend (global) .with (class {
 if (process.env.CDS_JEST_MEM_FIX && typeof jest !== 'undefined') require('./utils/jest.js')
 
 // Allow for import cds from '@sap/cds' without esModuleInterop
-Object.defineProperties(module.exports, { default: {value:module.exports}, __esModule: {value:true} })
+// FIXME: remove this flag in the next release. Only serves as fallback switch if people report issues with value:cds
+// Setting it to module.exports lead to issues with vitest while setting it to cds apparently works fine.
+if (process.env.CDS_ESM_INTEROP_DEFAULT) {
+  Object.defineProperties(module.exports, { default: {value:module.exports}, __esModule: {value:true} })
+} else { 
+  Object.defineProperties(module.exports, { default: {value:cds}, __esModule: {value:true} })
+}

package/lib/linked/types.js

@@ -66,6 +66,7 @@ const types = _common ({ __proto__: roots,
 	Time: {type:'date'},
 	DateTime: {type:'date'},
 	Timestamp: {type:'DateTime'},
+	Vector: {type:'Binary'},
 })
 
 /**

package/lib/log/format/json.js

@@ -66,7 +66,7 @@ module.exports = function format(module, level, ...args) {
   toLog.timestamp = new Date()
 
   // start message with leading string args (if any)
-  const i = args.findIndex(arg => typeof arg === 'object' && arg.message)
+  const i = args.findIndex(arg => typeof arg === 'object' && arg?.message)
   if (i > 0 && args.slice(0, i).every(arg => typeof arg === 'string')) toLog.msg = args.splice(0, i).join(' ')
 
   // merge toLog with passed Error (or error-like object)
@@ -86,6 +86,9 @@ module.exports = function format(module, level, ...args) {
   // append remaining args via util.format()
   if (args.length) toLog.msg = toLog.msg ? util.format(toLog.msg, ...args) : util.format(...args)
 
+  // ensure type (required on kubernetes if logs are pulled instead of pushed through binding)
+  toLog.type ??= 'log'
+
   // REVISIT: should not be necessary with new protocol adapters
   // 4xx: lower to warning (if error)
   if (toLog.level && toLog.level.match(/error/i) && _is4xx(toLog)) toLog.level = 'warn'

package/lib/plugins.js

@@ -37,8 +37,8 @@ exports.activate = async function () {
     const p = require (conf.impl)
     if(p.activate) {
       cds.log('plugins').warn(`WARNING: \n
-  Returning an 'activate' function is deprecated and won't be
-  supported in future releases. → Please return a Promise with 'module.exports' instead.
+  The @sap/cds plugin ${conf.impl} contains an 'activate' function, which is deprecated and won't be
+  supported in future releases. Please rewrite the plugin to return a Promise within 'module.exports'.
   `)
       await p.activate(conf)
     }

package/lib/ql/SELECT.js

@@ -201,13 +201,10 @@ const _projection4 = (fn) => {
         apply: (_, __, args) => { // handle nested projections e.g. (foo)=>{ foo.bar (b=>{ ... }) }
           const [a, b] = args
           if (!a) col.expand = ['*']
-          else if (a.raw) {
-            if (a[0] === '*') col.expand = ['*']
-            else if (a[0] === '.*') col.inline = ['*']
-            else {
-              let {columns} = SELECT_(col.ref[col.ref.length-1] +' ', args, ' from X')
-              Object.assign (col, columns[0])
-            }
+          else if (a.raw) switch (a[0]) {
+            case  '*': col.expand = ['*']; break
+            case '.*': col.inline = ['*']; break
+            default: Object.assign (col, SELECT_(col.ref.at(-1)+' ', args, ' from X').columns[0])
           }
           else if (Array.isArray(a)) col.expand = _columns(a)
           else if (a === '*') col.expand = ['*']
@@ -215,7 +212,10 @@ const _projection4 = (fn) => {
           else if (typeof a === 'string') col.ref.push(a)
           else if (typeof a === 'function') {
             let x = (col[/^\(?_\b/.test(a) ? 'inline' : 'expand'] = _projection4(a))
-            if (b && b.levels) while (--b.levels) x.push({ ...col, expand: (x = [...x]) })
+            if (b?.levels) while (--b.levels) x.push({ ...col, expand: (x = [...x]) })
+          } else if (typeof b === 'function') {
+            let x = (col[/^\(?_\b/.test(b) ? 'inline' : 'expand'] = _projection4(b))
+            if (a?.depth) while (--a.depth) x.push({ ...col, expand: (x = [...x]) })
           }
           return nested
         },