@sap/cds-dk 9.3.1 → 9.4.1

package/bin/import.js

@@ -1,8 +1,8 @@
 module.exports = Object.assign(_import, {
     _name: 'import',
-    options:   ['--for', '--out', '--as', '--name', '--include-namespaces', '--dependencies', '--from', '--config', '--destination', '--group'],
-    shortcuts: ['-4',    '-o',    '-as',  '-n',     '-ns',                    '-d',            undefined,  '-c',       undefined,       undefined, '-', '-f'],
-    flags: ['--dry', '--force', '--no-copy', '--no-save', '--keep-namespace'],
+    options:   [ '--services', '--for', '--out', '--as', '--name', '--include-namespaces', '--dependencies', '--from', '--config', '--destination', '--group' ],
+    shortcuts: [ '-s', '-4',    '-o',    '-as',  '-n',     '-ns',                    '-d',            undefined,  '-c',       undefined,       undefined, '-', '-f'],
+    flags: [ '--dry', '--force', '--no-copy', '--no-save', '--keep-namespace', '--data-product', '--edmx', '--rfc', '--odata', '--openapi', '--asyncapi' ],
     help: `
 # SYNOPSIS
 
@@ -121,6 +121,11 @@ async function _import(args, options = {}) {
     await cds.plugins
     const cwd = process.cwd();
 
+    if (options['data-product']) {
+        const import_ = require ('./data-products/import.js')
+        return import_.exec (this)
+    }
+
     // process options
     const apiOptions = {};
     await common.processOptions(options, apiOptions);
@@ -140,6 +145,11 @@ async function _import(args, options = {}) {
     }
 
     let csn
+    if (options.edmx) options.from = 'edmx'
+    else if (options.odata) options.from = 'edmx'
+    else if (options.openapi) options.from = 'openapi'
+    else if (options.asyncapi) options.from = 'asyncapi'
+    else if (options.rfc) options.from = 'rfc'
     if (options.from) {
         if (!cds.import.from[options.from]) {
             // the required plugin might not be installed, e.g. rfc importer

package/bin/inspect.js

@@ -0,0 +1,226 @@
+#! /usr/bin/env node
+/* USAGE:
+cds inspect model.Req
+cds inspect model.Requisition --ids
+*/
+
+module.exports = Object.assign (inspect, {
+    options: [ '--stats', '--list', '--kind' ],
+  shortcuts: [ '-s', '-l', '-k' ],
+  help: `
+# SYNOPSIS
+
+    *cds inspect* [ <options> ]
+
+    Inspects the cds models of a project, or a specific definition.
+    Without arguments shows --stats a summary of your models.
+
+    You can list all definitions, and thereby filter the listed definitions
+    by kind, and/or a name pattern, using wildcards like * and ?.
+
+    For a specific definition you can list its elements, keys, associations,
+    compositions, or IDs using --list. It also shows where the definition
+    is inherited from, and counts of its elements.
+
+    See examples below.
+
+# OPTIONS
+
+    *-s | --stats*
+
+      Shows a summary of the kinds of definitions found.
+
+    *-l | --list* <names|elements|keys|associations|compositions|ids>
+
+      Lists the specified kind of elements of a specific definition.
+
+    *-k | --kind* <entity|type|service|...>
+
+      Filters the listed definitions by kind.
+
+# EXAMPLES
+
+    *cds inspect*
+    *cds inspect* --stats
+    *cds inspect* --kind aspect
+    *cds inspect* --list all
+    *cds inspect* --list names --kind entity
+    *cds inspect* --list names model.Req*
+    *cds inspect* requisition.model.Requisition
+    *cds inspect* requisition.model.Requisition --list elements
+    *cds inspect* requisition.model.Requisition --list ids
+    *cds inspect* requisition.model.Requisition --list keys
+    *cds inspect* requisition.model.Requisition --list associations
+    *cds inspect* requisition.model.Requisition --list compositions
+`})
+
+async function inspect(){
+
+  const cds = require ('../lib/cds')
+  const path = require ('node:path')
+
+  const { YELLOW, GREEN, CYAN, RED, GRAY, RESET } = cds.utils.colors
+  const i2 = ' '.repeat(2)
+  const i4 = ' '.repeat(4)
+  const args = process.argv.slice(3)
+
+  const option = (...oo) => {
+    for (let o of oo) {
+      const i = args.indexOf(o)
+      if (i>=0) return args.splice(i,2)[1] || ''
+    }
+  }
+
+  const fetch = { __proto__: {
+      get 'id elements' () { return this.ids },
+    },
+    names: () => true,
+    elements: () => true,
+    ids: e => e.name.match(/(ID|Id|id$)/),
+    keys: e => e.key,
+    associations: a => a.isAssociation && !a.isComposition,
+    compositions: a => a.isComposition,
+    'to-many': a => a.is2many,
+    'to-one': a => a.is2one,
+    unmanaged: a => a.is2one && a.on,
+    virtuals: e => e.virtual,
+    calculated: e => e.value,
+  }
+
+
+  const $location = d => {
+    if (Object.hasOwn(d,'$location')) return d.$location.file+':'+d.$location.line
+    let includes = d.parent?.includes; if (!includes) return ''
+    for (let inc of includes) {
+      let e = csn.definitions[inc]?.elements?.[d.name]
+      if (e) return $location(e)
+    }
+  }
+
+  const csn = await cds.load('*').then(cds.linked)
+  let defs = Object.values (csn.definitions)
+
+  const kinds = {
+    entities:   'entity',
+    aspects:    'aspect',
+    types:      'type',
+    services:   'service',
+    events:     'event',
+    actions:    'action',
+    functions:  'function',
+    contexts:   'context',
+    all:        undefined,
+  }
+
+  let kind = option ('-k','--kind')
+  let list = option ('-l','--list')
+  let stats = option ('-s','--stats')
+  if (list in kinds) [kind,list] = [kinds[list],'names']
+  if (kind) defs = defs.filter (d => d.kind === kind)
+  if (process.argv.length < 4) stats = true
+
+  const regexp4 = pattern => RegExp (pattern.replace(/\./g, '\\.').replace(/\*/g, '.*'))
+  for (let pattern of args) {
+    const regexp = regexp4(pattern || '.*')
+    defs = defs.filter (d => regexp.test(d.name))
+  }
+
+  console.log()
+  if (stats !== undefined) {
+
+    const count = (kind,f) => {
+      let n = defs.filter(f).length; if (!n) return
+      if (kind === 'entities') for (let each of ['.texts','.drafts']) {
+        let n = defs.filter(d => d.name.endsWith(each)).length
+        if (n) kind += ` - ${YELLOW}${n}${GRAY} ${each}`
+      }
+      if (n) console.log (YELLOW, n.toString().padStart(4,' '), GRAY + kind)
+    }
+    for (let k in kinds) count (k, d => d.kind === kinds[k])
+    console.log (GRAY, '-'.repeat(14), RESET)
+    console.log (YELLOW, defs.length.toString().padStart(4,' '), GRAY + 'in total')
+
+  } else {
+    defs = defs.filter (d => !d.name.match(/\.(texts|drafts)$/))
+    switch (list) {
+
+      case 'names':
+        const pad = kind?.length || 7 // eslint-disable-line no-case-declarations
+        defs.forEach (d => console.log (i2, RED + d.kind.padEnd(pad), GREEN + d.name))
+        console.log(GRAY+i2, '-'.repeat(27), RESET)
+        console.log(GRAY+i2, 'Total:', YELLOW + defs.length, GRAY + 'definitions')
+        break;
+
+      case 'sources':
+        csn.$sources.forEach(f => console.log (GRAY+i2, path.relative(cds.root,f)))
+        break;
+
+      default:
+        defs.forEach (inspect)
+
+    }
+  }
+  console.log(RESET)
+
+
+  function inspect (d) {
+
+    console.log(GRAY+i2, '-'.repeat(79), RESET)
+    console.log(GRAY+i2, 'Inspecting', RED + d.kind, GREEN + d.name, RESET)
+    console.log(GRAY+i2, '( declared at'+ CYAN, $location(d), GRAY+')', RESET)
+    console.log()
+
+    if (list !== undefined) {
+      const filter = fetch [list]
+      if (!filter) return console.error (RED, 'ERROR:'+ RESET, 'Use --list with one of:\n\n  ', Object.keys(fetch).join('\n   '), RESET)
+      const elements = Object.values(d.elements??{}).filter(filter)
+      const pad = elements.reduce((p, e) => Math.max(p, e.name.length), 0)
+      for (let e of elements) {
+        console.log (i4, GRAY + '-', YELLOW + e.name.padEnd(pad), GRAY, $location(e))
+      }
+      return console.log()
+    }
+
+    count(d.elements, 'keys')
+    count(d.elements, 'id elements')
+    count(d.elements, 'elements')
+    count(d.elements, 'associations', 'to-many', 'unmanaged')
+    count(d.elements, 'compositions', 'to-many')
+    count(d.elements, 'virtuals')
+    count(d.elements, 'calculated')
+
+    if (d.includes) {
+      console.log(RESET + '\n', i2, 'inherits: \n')
+      inheritance(d)
+    }
+    console.log()
+
+  }
+
+  function inheritance (d, indent = '') {
+    if (d.includes) for (let each of d.includes) {
+      let d = csn.definitions[each]
+      console.log(i4, ' -', count(d.elements), GRAY + 'elements from' + indent, RED + d.kind, GREEN + d.name, RESET)
+      inheritance(d, indent + i2)
+    }
+  }
+
+  function count (defs, kind, ...more) {
+    if (!defs) return
+    if (!Array.isArray(defs)) defs = Object.values(defs)
+    if (kind) {
+      const filter = fetch[kind]
+      if (filter) defs = defs.filter(filter)
+      if (!defs.length) return
+    }
+    let info = YELLOW+ defs.length.toString().padStart(3, ' ')
+    if (kind) info += GRAY + ' ' + kind; else return info
+    for (let kind of more) {
+      let filter = fetch[kind] || fetch[kind.replace(/-/g,'_')]
+      let n = defs.filter(filter).length
+      if (n) info += ', '+ YELLOW + defs.filter(filter).length + GRAY+' ' + kind
+    }
+    console.log (i4, info, GRAY)
+  }
+
+}

package/bin/minify.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+const cds = require ('../lib/cds.js')
+const { Minifier } = cds.minify;  if (!Minifier) throw new Error ('@sap/cds >= 9.4.0 required for this command')
+const { Command } = require ('./util/cli.js')
+const { inspect } = require ('node:util')
+
+class Minify extends Command {
+
+  options = Minify.options // for IntelliSense
+  static options = {
+    cleanse: { _excluding: 'keep' },
+    keep: { _excluding: 'skip',
+      aspect: false,
+      entity: true,
+      event: true,
+      type: false,
+      action: true,
+      function: true,
+    },
+    skip: {},
+    dry: false,
+    debug: false,
+    inspect: false,
+  }
+  static shortcuts = { skip:'x', dry:'y' }
+  static filename = __filename
+
+  parseArgs (conf) {
+    let [sources,o] = super.parseArgs (conf)
+    this.sources = sources.length ? o.from = sources : sources = o.from || '*'
+    return [sources,o]
+  }
+
+  async exec ( args, options ) {
+    let [sources,o] = this.parseArgs ({ args, options })
+    try {
+      let csn = await this.load (sources,o); this.csn = csn
+      let min = await this.minify (csn,o); this.min = min
+      if (o.dry) return
+      if (o.inspect) return this.inspect (min,o)
+      if (this.print) return this.print (min)
+      else await this.export (min,o)
+      console.log()
+    } catch (e) {
+      if (typeof e === 'string') return console.error (e)
+      if (e.code) return console.error (e.message)
+      else throw e
+    }
+  }
+
+  /**
+   * Subclasses override this method to provide custom loading behavior.
+   */
+  async load (sources,o) { // eslint-disable-line no-unused-vars
+    return cds.load (sources)
+  }
+
+  /**
+   * Subclasses override this method to provide custom cleansing behavior.
+   */
+  async cleanse (csn,o) { // eslint-disable-line no-unused-vars
+    return csn
+  }
+
+  /**
+   * Subclasses override this method to provide custom minification behavior.
+   */
+  async minify (csn,o) {
+    let m = this.minifier ??= o.dry ? new Dryifier(csn) : new Minifier()
+    csn = await this.cleanse (csn,o)
+    return m.minify (csn,o)
+  }
+
+  /**
+   * Subclasses override this method to generate exported artifacts.
+   */
+  export (csn,o) {} // eslint-disable-line no-unused-vars
+
+  /**
+   * Subclasses override this method to provide custom print behavior.
+   */
+  print (csn,o) { // eslint-disable-line no-unused-vars
+    console.log (cds.compile.to.json (csn))
+  }
+
+  inspect (csn, {inspect:depth} = this.options) {
+    const colors = cds.utils.colors.enabled
+    console.log (inspect (cds.linked(csn), { depth, colors }))
+  }
+}
+
+
+/**
+ * Custom minifier to capture kept definitions in dry run mode
+ */
+class Dryifier extends Minifier {
+
+  constructor(csn) { super(); this.all = Object.keys (csn.definitions) }
+  capture = {}
+  level = 0
+
+  keep (each,d) {
+    if (each in this.kept) return; else this.capture[each] = ++this.level
+    super.keep (each, d)
+    this.level--
+  }
+
+  minify (csn,o) {
+    const { GREEN, GRAY, DIMMED, RESET } = cds.utils.colors
+    const min = super.minify (csn, o)
+    const kept = Object.keys(this.capture)
+    console.log (RESET+'\n', 'Keep:', kept.length, '\n')
+    for (let [ each, level ] of Object.entries(this.capture))
+      console.log ('  '+GRAY,'•'.repeat(level)+GREEN, each, RESET)
+    console.log (RESET+'\n', 'Skip:', this.all.length - kept.length, '\n')
+    for (let each of this.all)
+      each in this.capture || console.log (DIMMED, '  -', each, RESET)
+    console.log (RESET+'\n', 'Total:', this.all.length, '\n')
+    return min
+  }
+}
+
+module.exports = Object.assign (Minify._for_cds_dk(), { Minify })

package/bin/up.js

@@ -27,9 +27,9 @@ module.exports = Object.assign(up, {
   *cds up --to k8s --namespace e2e-tests*
 `})
 
-const { execSync, spawn } = require('node:child_process')
+const { execSync } = require('node:child_process')
 const cds = require('../lib/cds')
-const { highlight, bold } = require('../lib/util/term')
+const { highlight } = require('../lib/util/term')
 const { exists, fs, path, path: { join } } = cds.utils
 const { readProject } = require('../lib/init/projectReader')
 
@@ -45,27 +45,6 @@ const run = cmd => {
   }
 }
 
-const runDetectingError = async (cmd, errorRegex) => {
-  console.log(highlight(cmd))
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, { shell: true, stdio: 'pipe' })
-    let out = '';
-    ['stdout', 'stderr'].forEach(key => {
-      child[key].on('data', data => {
-        process[key].write(data.toString())
-        out += data.toString()
-      })
-    })
-    child.on('close', () => {
-      const error = out.match(errorRegex)
-      if (error) {
-        return reject('Error in command: ' + bold(cmd) + ' → exiting')
-      }
-      resolve(out)
-    })
-  })
-}
-
 async function up() {
   const project = readProject()
   const { apps, appName, hasApprouter, hasXsuaa, isMonorepoMicroservice } = project
@@ -121,7 +100,7 @@ async function up() {
     const nsKubectl = ns ? `-n ${ns}` : ''
 
     run('npm i --package-lock')
-    await runDetectingError('ctz containerize.yaml --log --push', /^\[?ERROR\]?.*/m)
+    run('ctz containerize.yaml --log --push')
     let helmUpgrade = `helm upgrade --install ${appName} ./gen/chart ${nsHelm} --wait --wait-for-jobs --timeout=10m`
     if (hasXsuaa) helmUpgrade += ' --set-file xsuaa.jsonParameters=xs-security.json'
     run(helmUpgrade)

package/bin/util/cli.js

@@ -0,0 +1,132 @@
+const { parseArgs } = require ('node:util')
+const path = require ('node:path')
+const fs = require ('node:fs')
+
+class Command { static filename = __filename // to be overridden in subclasses
+
+  get class(){ return this.constructor }
+  get name(){ return this.class.name }
+
+    /** @type <T>(defaults: T) => [ string[], T ] */
+  parseArgs (conf) {
+
+    const args = conf.args || process.argv.slice(2)
+    const shorts = { ...this.class.shortcuts, ...conf.shortcuts }
+    const options = { ...this.class.options, ...conf.options, help:false }
+    for (let k in options) options[k] = option4 (options[k]) .short (shorts[k]||k[0])
+
+    // parse the CLI args with node:util.parseArgs
+    const { positionals:p, values:o } = parseArgs ({
+      allowPositionals: true, strict: false, ...conf,
+      args, options,
+    })
+    this.positionals = p
+    this.options = o
+
+    // convert the parsed values according to the options
+    for (let k in o) {
+      const v = options[k]; if (!v) continue
+      if (v.convert) o[k] = v.convert (o[k],o)
+    }
+
+    // help / debug
+    if (o.help || args == '?' || !args.length) throw this.help()
+    if (o.debug) throw this.debug()
+
+    // parsed
+    return [ this.positionals, this.options ]
+  }
+
+  usage() {
+    const source = this.class.filename; if (!source) return super.usage = undefined
+    const { dir, name } = path.parse (source)
+    const md = path.join(dir,'help',name+'.md')
+    return super.usage = fs.readFileSync (md,'utf8')
+  }
+
+  help (usage = this.usage()) {
+    console.log (usage
+      .replace(/\n# ([^\n]*)\n/g, `\n\x1b[1m$1\x1b[0m\n`)
+      .replace(/ \*([^*]+)\*/g,   ` \x1b[1m$1\x1b[0m`)
+      .replace(/ _([^_]+)_/g,     ` \x1b[4m$1\x1b[0m`)
+    )
+    process.exit(0)
+  }
+
+  debug (positionals = this.positionals, o = this.options) {
+    console.log('Debugging information:')
+    const shortcuts = {}, options = {...o}; delete options.o
+    for (let o in options) shortcuts[this.class.shortcuts[o] || o[0]] = o
+    console.log ({ positionals, options, shortcuts })
+    process.exit(0)
+  }
+
+  static _for_cds_dk (cmd = this) {
+    return { _is_new_cmd: true,
+      options: Object.keys(this.options).map(o => '--'+o), // for shell completion
+      exec() { return (new cmd) .exec (process.argv.slice(3)) },
+      get help() { return (new cmd).usage() },
+    }
+  }
+}
+
+
+class Option {
+  constructor (spec) { Object.assign (this,spec) }
+  convert (x) { return x }
+  to(fn) { this.convert = fn; return this }
+  short(sc) { this.short = sc; return this }
+  get array() { this.multiple = true; return this }
+}
+
+class Flags extends Option {
+  constructor (defaults) {
+    super({
+      type: 'string',
+      multiple: true,
+      default: [],
+      defaults,
+    })
+    if (defaults._excluding) {
+      this.skip = defaults._excluding
+      delete defaults._excluding
+    }
+  }
+  convert (strings,o) {
+    const flags = { ...this.defaults }
+    const keep = strings4(strings).reduce?.((o,x)=>(o[x]=true,o),{}) || strings
+    if (keep.all) for (let x in this.defaults) flags[x] = true
+    if (this.skip) {
+      const skip = o[this.skip].reduce?.((o,x)=>(o[x]=true,o),{}) || o[this.skip]
+      if (skip.all) for (let x in this.defaults) delete flags[x]
+      else for (let x in skip) delete flags[x]
+    }
+    for (let x in keep) flags[x] = keep[x]
+    return flags
+  }
+}
+
+const option4 = exports.option4 = (v) => {
+  if (v instanceof Option)    return v
+  if (v instanceof RegExp)    return pattern(v)
+  if (v instanceof Array)     return strings(v)
+  if (v == null)              return string('')
+  if (typeof v === 'string')  return string(v)
+  if (typeof v === 'object')  return flags(v)
+  if (typeof v === 'boolean') return flag(v)
+  if (typeof v === 'number')  return number(v)
+}
+const option = exports.option = (x) => new Option (x)
+const number = exports.number = d => string (String(d)).to(Number)
+const pattern = exports.pattern = d => string (d.source !== '.' ? [d.source] : []) .array.to (regex4)
+const strings = exports.strings = d => string (d.length ? d : undefined) .array.to (strings4)
+const string = exports.string = d => option ({ type:'string', default:d })
+const flag = exports.flag = d => option ({ type:'boolean', default:d })
+const flags = exports.flags = (d,x) => new Flags (d,x)
+const regex4 = exports.regex4 = raw => RegExp (strings4(raw).join('|')
+  .replaceAll ('.','\\.')
+  .replaceAll ('*','.*'),
+'i')
+const strings4 = exports.strings4 = raw => raw.length === 1 ? raw[0].split?.(',')||'' : raw
+
+exports.Command = Command

package/bin/util/log.js

@@ -15,6 +15,8 @@ module.exports = (messages, options={}) => {
     error: { Error:4, undefined:4 },
   } [logLevel.toLowerCase()] || { Error:4, undefined:4, Warning:3 }
   const log = options.log || console.error
+  // cds10: Remove cds.utils.colors.for check
+  if (log === console.error && cds.utils.colors.for) format.colors = cds.utils.colors.for(process.stderr).enabled
 
   if (!Array.isArray (messages))  messages = [messages]
   for (let m of messages.filter (m => m.severity in levels)) {

package/bin/version.js

@@ -145,7 +145,8 @@ function _pkg_path(id, ...paths) {
 }
 
 function capJavaVersion(cwd) {
-  const cmd = 'mvn com.sap.cds:cds-maven-plugin:version -B -Dcds.version.excludeCds -Dcds.version.json'
+  const { MAVEN_ARCHETYPE_VERSION } = require('../lib/init/constants')
+  const cmd = `mvn com.sap.cds:cds-maven-plugin:${MAVEN_ARCHETYPE_VERSION}:version -B -ntp -Dcds.version.excludeCds -Dcds.version.json`
 
   let out = ''
   try {

package/bin/watch.js

@@ -1,7 +1,7 @@
 const watchOnlyOptions = ['--ext', '--livereload', '--open', '--debug', '--inspect', '--inspect-brk', '--include', '--exclude']
 
 module.exports = Object.assign ( watch, {
-  flags: [ '--in-memory', '--in-memory?', '--with-mocks' ],
+  flags: [ '--in-memory', '--in-memory?', '--with-mocks', '--with-mtx' ],
   options: [ '--port', ...watchOnlyOptions ],
   help: `
 # SYNOPSIS
@@ -51,6 +51,11 @@ module.exports = Object.assign ( watch, {
     Specify from which profile(s) the binding information is taken.
     *Example:* cds w --profile hybrid,production
 
+  *--with-mtx*
+
+    A shortcut for _--profile with-mtx_ to enable mtx features also in
+    development, while by default, these are only enabled in production.
+
   *--debug* / *--inspect* <host:port | 127.0.0.1:9229>
 
     Activate debugger on the given host:port.
@@ -67,11 +72,11 @@ module.exports = Object.assign ( watch, {
 
 `})
 
+const fs = require ('node:fs')
 const cds = require('../lib/cds')
 const DEBUG = /\b(y|all|cli|watch)\b/.test (process.env.DEBUG) ? ((..._) => console.debug ('[cli] -', ..._)) : undefined
 const {delimiter,relative,resolve,sep} = require ('path')
 const {codes} = require('../lib/util/term'), t = codes
-const fs = require ('fs')
 
 const escapedSep = sep === '\\' ? '\\\\' : sep // escape backslash for windows
 const ignoreDefaults = [
@@ -99,6 +104,7 @@ async function watch ([cwd], {
   const log = (first,...more) => console.log (t.yellow + (first||''), ...more, t.reset)
   const paths4 = p => typeof p === 'string' ? p.split(',').map(p => p.trim()) : (p || [])
   const included = paths4(include), excluded = paths4(exclude)
+  const isJava = fs.existsSync('pom.xml') && process.env.CDS_ENV !== 'node'
 
   if (!Object.keys(options).includes('with-mocks'))               args.push ('--with-mocks')
   if (!Object.keys(options).find(a => /^in-memory\??$/.test(a)))  args.push ('--in-memory?')
@@ -118,7 +124,8 @@ async function watch ([cwd], {
   }
   else cwd = cds.root
 
-  log (`\n${t.bold}cds ${args.join(' ')}`)
+  if (isJava) options.livereload = false
+  if (!isJava) log (`\n${t.bold}cds ${args.join(' ')}`)
 
   const env = Object.assign (process.env, {
     _args: JSON.stringify(args),
@@ -164,6 +171,17 @@ async function watch ([cwd], {
     Object.assign(env, await bind.env({cwd}))
   }
 
+  // if (isJava) {
+  //   const { spawn } = require('node:child_process')
+  //   const path = require('node:path')
+  //   const cwd = path.join(cds.root, cds.env.folders.srv)
+  //   const child = spawn('mvn', ['cds:watch'], { cwd, stdio: 'inherit' })
+  //   child.on('close', (code) => {
+  //     if (code !== 0) console.error(`mvn process exited with code ${code}`)
+  //   })
+  //   return
+  // }
+
   const nodemon = require('../lib/watch/node-watch')
   const watcher = nodemon ({
     script: resolve(__dirname,'../lib/watch/watched'), cwd, env, ext, ignore, watched,

package/lib/bind/shared.js

@@ -82,7 +82,9 @@ async function bind(options = { on: 'cf' }) {
             if (!requiresName) throw `unknown CDS service name for service ${bold(instance)} of kind ${bold(kind)} – please specify as argument for ${bold('cds bind')}`
             resolved.name = requiresName
         }
-        resolved.name ??= `custom-service:${instance || secret}`
+        if (exists('pom.xml')) resolved.name ??= `custom-service:${instance || secret}`
+        else resolved.name ??= `${instance || secret}`
+
         const kindText = kind ? ` with kind ${bold(kind)}` : ''
         console.log(`binding ${bold(resolved.name)} to ${plugin.displayName()} ${_bindingText(binding)}${kindText}`)
     }

package/lib/build/buildTaskEngine.js

@@ -6,7 +6,7 @@ const { inspect } = require('node:util')
 const cds = require('../cds'), { _log: log } = cds
 const { sortMessagesSeverityAware, deduplicateMessages, CompilationError } = cds.compiler
 const { relativePaths, BuildError, BuildMessage, resolveRequiredSapModels } = require('./util')
-const { SEVERITIES, LOG_LEVELS } = require('./constants')
+const { SEVERITIES, SEVERITY_ERROR, LOG_LEVELS } = require('./constants')
 const BuildTaskFactory = require('./buildTaskFactory')
 const InternalBuildPlugin = require('./provider/internalBuildPlugin')
 const COMPILATION_ERROR = 'CompilationError'
@@ -195,6 +195,7 @@ class BuildTaskEngine {
             const error = errors.find(e => e.constructor.name !== COMPILATION_ERROR)
             if (error) {
                 // throw original BuildError including existing BuildMessages
+                error.messages = error.messages.map(m => typeof m === 'string' ? new BuildMessage(m, SEVERITY_ERROR) : m)
                 error.messages = this._sortMessagesUnique(pluginMessages.filter(m => m instanceof BuildMessage), error.messages)
                 throw error
             }