@sap/cds-dk 8.4.2 → 8.5.1

package/CHANGELOG.md

@@ -3,9 +3,48 @@
 
 All notable changes to this project will be documented in this file.
 
-This project adheres to [Semantic Versioning](http://semver.org/).
+This project adheres to [Semantic Versioning](https://semver.org/).
 
-The format is based on [Keep a Changelog](http://keepachangelog.com/).
+The format is based on [Keep a Changelog](https://keepachangelog.com/).
+
+## Version 8.5.1 - 2024-12-05
+
+### Added
+
+- `cds watch` now detects a TypeScript project and tries to run with `tsx` if this is installed locally or globally. Otherwise a warning message is emitted.  `CDS_TYPESCRIPT=false` can be used to opt out of this behavior.
+
+### Fixed
+
+- `cds add html5-repo` adds an `index.html` as `welcomePage` to the `xs-app.json`, if available.
+- `cds build` now logs existing plugin build messages if a BuildError is thrown.
+
+## Version 8.5.0 - 2024-11-26
+
+### Changed
+
+-  `cds import` now generates generic action/function in case of bound action/function collision and unbound function collision with @cds.validate = false.
+- `cds add typescript` creates projects with `cds-tsx` to run apps instead of former `cds-ts`.
+- `cds deploy` writes error output to `stderr`.
+- `cds add http` now evaluates mocks users when creating `Authorization` headers
+
+### Added
+
+- `cds debug` lets you debug Node.js applications running locally or in Cloud Foundry.
+- `cds watch --inspect` and `cds watch --inspect-brk` activate the debugger in the same way as the standard Node.js CLI options, i.e. they accept a `host:port` combination and `0` as values.
+- The existing `cds watch --debug` is now an alias to `cds watch --inspect`.
+- `cds add cloud-logging` adds cloud-logging as an alternative for application logging in Kyma.
+- `cds add cloud-logging --with-telemetry` or `cds add telemetry` adds cloud-logging as well as support for `cap-js/telemetry` plugin in Kyma.
+- `cds add handler` now also works for Node.js projects. It creates an implementation file for each service with event handlers for all entites and actions.
+- `cds add esm` creates ESM-compatible Node.js projects. Sample code added by `add sample` and `add handler` will respect this setting if added aftwards. Existing code will not be adjusted by `cds add esm`, though.
+
+### Fixed
+
+- `cds import` throws proper error message if Annotation element doesn't have Term attribute.
+- `cds add approuter` no longer enforces Node.js 22, which is not supporter by current `@sap/approuter` version 17. The previous Node.js version 20 is used again.
+- `cds add -p` with custom options now works if the entry was not in the `package.json` beforehand.
+- `cds add http` works for actions without parameters.
+- `cds add workzone` includes the `updateManifestJson` task on initial generation.
+- `cds build --ws` no longer creates migration tables in shared database or wrong workspace.
 
 ## Version 8.4.2 - 2024-11-19
 
@@ -23,7 +62,6 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `cds add hana` adds the `requires.db` entry to `.cdsrc.json` for Java projects.
 - `cds add data` creates decimal values with correct scale `0` if only precision is given, like in `Decimal(15)`.
 
-
 ## Version 8.4.1 - 2024-11-08
 
 ### Added

package/bin/cds.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 
+const path = require('node:path')
+const { sep } = { path }
+const fs = require('node:fs')
 
 const cli = {
 
@@ -25,9 +28,6 @@ const cli = {
   },
 
   async exec (cmd = process.argv[2], ...argv) {
-    const path = require('node:path')
-    const fs = require('node:fs')
-
     if (!argv.length) argv = process.argv.slice(3)
     if (!cmd) cmd = process.stdin.isTTY ? 'help' : 'compile'
     if (cmd in this.Shortcuts) cmd = process.argv[2] = this.Shortcuts[cmd]
@@ -66,7 +66,10 @@ const cli = {
             const p = argv[argv.indexOf('-p') + 1] || argv[argv.indexOf('--package') + 1]
             console.log(`running with --package, adding dependency ${p}`)
             await require('../lib/util/command').spawnCommand(`npm`, ['add', p], { cwd: cds.root })
+            delete require.cache[require.resolve(path.join(cds.root,'./package.json'))]
           }
+          cds.env.plugins = cds.env.for('cds').plugins // reload plugin env
+          cds.add = require('../lib/init/add')
           await cds.plugins
           for (const [, Plugin] of cds.add.registered) {
             const all = Object.entries((new Plugin).options())
@@ -86,13 +89,8 @@ const cli = {
 
         if (args[1]?.['resolve-bindings']) await _resolveBindings({ silent: cmd === 'env' })
 
-        // warn users if they are using cds instead of cds-ts in a TypeScript project
-        const tsconfig = path.join(cds.root ?? '.', 'tsconfig.json')
-        if (!process.env.CDS_TYPESCRIPT && cds.cli?.command === 'serve' && fs.existsSync(tsconfig)) {
-          // cds.root may for some subcommands not point to the correct directory (e.g. cds w where users can pass a project directory)
-          // showing the full detected path should give the user an idea whether this info is relevant for them
-          console.error(`Detected ${tsconfig}. If this is a TypeScript project, consider running commands using 'cds-ts' instead of 'cds'.\n`)
-        }
+        _prepareTsIfNeeded(cds)
+
         return await task.apply(this, args)
       }
     } catch (e) {
@@ -231,24 +229,6 @@ function _dieForUnknownCommand(cmd) {
   throw msg;
 }
 
-function _require (id,o) {
-  try { var resolved = require.resolve(id,o) } catch(e){ DEBUG?.(`[cds] - Command not found: ${id}`); return }
-  DEBUG?.(`[cds] - Command resolved: ${resolved}`)
-  return require (resolved)
-}
-
-const { sep } = require ('path')
-if (process[Symbol.for('ts-node.register.instance')])
-  process.env.CDS_TYPESCRIPT = 'ts-node'
-else if (process._preload_modules?.some(m => m?.includes(`${sep}tsx${sep}`)))
-  process.env.CDS_TYPESCRIPT = 'tsx'
-
-module.exports = Object.assign ((..._) => cli.exec(..._), cli)
-
-if (!module.parent)  module.exports()
-
-
-
 function getCommands() {
   const fs = require('node:fs');
   const path = require('node:path');
@@ -267,4 +247,45 @@ function getCommands() {
   return Array.from(result).sort()
 }
 
+function _require (id,o) {
+  try { var resolved = require.resolve(id,o) } catch(e){ DEBUG?.(`[cds] - Command not found: ${id}`); return }
+  DEBUG?.(`[cds] - Command resolved: ${resolved}`)
+  return require (resolved)
+}
+
+module.exports = Object.assign ((..._) => cli.exec(..._), cli)
+if (!module.parent)  module.exports()
+
+// check for an already loaded TS runner
+if (process[Symbol.for('ts-node.register.instance')])
+  process.env.CDS_TYPESCRIPT = 'ts-node'
+else if (process._preload_modules?.some(m => m?.includes(`${sep}tsx${sep}`)))
+  process.env.CDS_TYPESCRIPT = 'tsx'
+
+/**
+ * Load tsx if needed in a TS project. Warn users if this fails.
+ */
+function _prepareTsIfNeeded(cds) {
+  const tsconfig = path.join(cds.root ?? '.', 'tsconfig.json')
+  if (cds.cli?.command === 'serve' && fs.existsSync(tsconfig)) { // for `cds serve` started directly or through watch
+    if (/\b(0|no|false)\b/.test(process.env.CDS_TYPESCRIPT))  // opt-out switch to run JS code in a TS project
+      return delete process.env.CDS_TYPESCRIPT
+
+    if (!process.env.CDS_TYPESCRIPT ) {
+      try {
+        cds._localOrGlobal('tsx/cjs') // cjs is needed as we are in CJS code
+        console.log(`Detected ${path.relative(cds.root, tsconfig)}. Running with tsx.\n`)
+        process.env.CDS_TYPESCRIPT = 'tsx'
+      }
+      catch (e) {
+        if (e.code !== 'MODULE_NOT_FOUND') throw e
+        // cds.root may for some subcommands not point to the correct directory (e.g. cds w where users can pass a project directory)
+        // showing the full detected path should give the user an idea whether this info is relevant for them
+        console.error(`Detected ${tsconfig}. If this is a TypeScript project, consider running commands using 'cds-ts' or 'cds-tsx' instead of 'cds'.\n`)
+      }
+    }
+  }
+
+}
+
 /* eslint no-console:off */

package/bin/debug.js

@@ -0,0 +1,90 @@
+module.exports = Object.assign(debug, {
+    options: ['--port', '--host'],
+    shortcuts: [],
+    flags: [/*'--vscode', '--k8s'*/],
+    help: `
+# SYNOPSIS
+
+    *cds debug* [<app>]
+
+    Debugs a CAP-based application in the Chrome Developer Tools.
+
+    If <app> is given, it's assumed to be running on the currently logged-in Cloud Foundry space.
+
+    If no <app> is given, the app in the current working is started with 'cds watch --debug'.
+
+# OPTIONS
+
+    *--host* the debug host (default: '127.0.0.1')
+
+    *--port* the debug port (default: 9229)
+
+# EXAMPLES
+
+    *cds debug*
+    *cds debug* bookshop-srv
+`})
+
+async function debug() {
+  const cds = require('../lib/cds')
+  const { fork, spawn, execSync, exec } = require('node:child_process')
+  const os = require('node:os').platform()
+
+  const [appName] = cds.cli.argv
+  const { port = 9229, host = '127.0.0.1', vscode } = cds.cli.options
+  const ide = vscode ? 'vscode' : 'chrome'
+
+  if (!appName) { // local app
+    const script = process.argv[1] // `.../cds` or `.../cds-tsx`
+    console.log(`Starting '${cds.utils.path.basename(script)} watch --debug'`)
+    fork(script, ['watch', '--debug']).on('error', e => { throw 'Failed to start debug process:' + e.message })
+  } else if (cds.cli.options.k8s) { // Kyma/Kubernetes
+    // to be implemented
+  } else { // Cloud Foundry
+    const script = `ps aux | grep '[n]ode' | awk '{print \\$2}' | head -n 1`
+    const pid = execSync(`cf ssh ${appName} -c "${script}"`, { encoding: 'utf-8', shell: true }).trim()
+    if (!pid) throw `Node.js process for app '${appName}' not found`
+    execSync(`cf ssh ${appName} -c "kill -usr1 ${pid}"`, { stdio: 'inherit' })
+    console.log(`Opening SSH tunnel for CF app '${appName}'`)
+    spawn('cf', ['ssh', '-N', '-L', `${port}:${host}:${port}`, appName], { stdio: 'inherit' })
+  }
+
+  const maxAttempts = 15
+  let attempts = 0
+
+  const openDevTools = async () => {
+    attempts++
+    try {
+      switch (ide) {
+        case 'chrome': {
+          const res = await fetch(`http://localhost:${port}/json/list`)
+          const data = await res.json()
+          if (!data?.length) throw 'No debugger found on port ' + port
+          const wsUrl = data[0].webSocketDebuggerUrl
+          let command
+          const url = `devtools://devtools/bundled/inspector.html?ws=${wsUrl.split('ws://')[1]}`
+          console.log(`Opening Chrome DevTools at ${url}`)
+          if (os === 'darwin') {
+            command = `open -a "Google Chrome" '${url}'`
+          } else if (os === 'win32') {
+            command = `start chrome "${url}"`
+          } else {
+            command = `google-chrome '${url}' || chromium-browser '${url}' || chromium '${url}'`
+          }
+          exec(command, (error) => { if (error) throw 'Failed to open DevTools: ' + error.message })
+          break
+        }
+        case 'vscode': {
+          // to be implemented
+        }
+      }
+    } catch (err) {
+      if (attempts < maxAttempts) {
+        setTimeout(openDevTools, 1000) // connection fails sometimes, retry
+      } else {
+        throw `Failed to connect to debugger after ${maxAttempts} attempts: ${err}`
+      }
+    }
+  }
+  openDevTools()
+}

package/bin/repl.js

@@ -42,13 +42,59 @@ async function repl (_, options={}) {
   const ctx={}
 
   repl.defineCommand ('run', {
-    help: 'Runs a cds server in the given CAP project folder, which can be a module name like @capire/bookshop.',
+    help: 'Runs a cds server from a given CAP project folder, or module name like @capire/bookshop.',
     async action (project) {
       // await cds.exec ('--project', project, '--port', '0')
       await cds.test (project)
-      console.log ('Following are made avaliable as global variables:')
-      console.log ('- cds.services:', Object.keys(cds.services)); Object.assign (repl.context, cds.services)
-      console.log ('- cds.entities:', Object.keys(cds.entities)); Object.assign (repl.context, cds.entities)
+
+      const GREEN = '\x1b[32m', RESET = '\x1b[0m'
+      console.log ('------------------------------------------------------------')
+      console.log ('Following are made available as repl globals:')
+      console.log()
+      let ntt = _export ('entities')
+      let srv = _export ('services')
+      console.log()
+      console.log('Simply type e.g.', GREEN+ntt+RESET, 'or', GREEN+srv+RESET, 'in the prompt to use the respective objects.')
+      console.log()
+      this.displayPrompt()
+
+      function _export (cds_property) {
+        let exports = cds[cds_property], first
+        console.log (`from cds.${cds_property}: {`)
+        for (let each in exports) {
+          if (each.includes('.')) continue
+          repl.context[each] = exports [each]
+          console.log (`  ${GREEN}${each}${RESET},`)
+          first ??= each
+        }
+        console.log (`}`)
+        return first
+      }
+    },
+  })
+
+  repl.defineCommand ('inspect', {
+    help: 'Sets options for util.inspect, e.g. `.inspect .depth=1`.',
+    async action (_args) {
+      const args = _args.split(' '), subjects={}, options = {}, defaults = inspect.defaultOptions
+      for (let each of args) {
+        // args of shape .<option>=<value> set inspect options
+        if (each[0] === '.') each = eval(`options${each}`)
+        // others are subjects to inpsect with given options
+        else subjects[each ||= 'defaults'] = each === 'defaults' ? defaults : function _recurse (o,slug) {
+          const [ head,...tail ] = slug, x = o[head]
+          if (tail.length && x && typeof x === 'object') return _recurse (x,tail)
+          else return x
+        } (repl.context, each.split('.'))
+      }
+      // if no subjects were given, just set the options globally
+      if (!Object.keys(subjects).length) {
+        Object.assign (defaults, options)
+        console.log('\n', 'updated node:util.inspect.defaultOptions with:', options)
+      } else for (let [each,subject] of Object.entries(subjects))
+        console.log ('\n'+each+':', inspect (subject, options))
+      console.log()
+      this.displayPrompt()
     }
   })
 

package/bin/watch.js

@@ -1,6 +1,6 @@
-const watchOnlyOptions = ['--ext', '--livereload', '--open']
+const watchOnlyOptions = ['--ext', '--livereload', '--open', '--debug', '--inspect', '--inspect-brk']
 module.exports = Object.assign ( watch, {
-  flags: [ '--debug', '--in-memory', '--in-memory?', '--with-mocks' ],
+  flags: [ '--in-memory', '--in-memory?', '--with-mocks' ],
   options: [ '--port', ...watchOnlyOptions ],
   help: `
 # SYNOPSIS
@@ -42,6 +42,16 @@ module.exports = Object.assign ( watch, {
     Specify from which profile(s) the binding information is taken.
     *Example:* cds w --profile hybrid,production
 
+  *--debug* / *--inspect* <host:port | 127.0.0.1:9229>
+
+    Activate debugger on the given host:port.
+    If port 0 is specified, a random available port will be used.
+
+  *--inspect-brk* <host:port | 127.0.0.1:9229>
+
+    Activate debugger on the given host:port and break at start of user script.
+    If port 0 is specified, a random available port will be used.
+
 # SEE ALSO
 
   *cds serve --help* for the different start options.
@@ -72,7 +82,7 @@ async function watch ([cwd], {
   ...options
 }={}) {
   if (cwd && !cds.utils.exists(cwd)) try { // try module name like `@capire/bookshop`
-    cwd = require.resolve(cwd+'/package.json').slice(0,-13)
+    cwd = require.resolve(cwd+'/package.json', {paths:[ process.cwd() ]}).slice(0,-13)
   } catch (err) {
     throw `Error: No such folder or package: '${cwd}'`
   }

package/lib/bind/userCdsrcJsonStorageProvider.js

@@ -1,6 +1,5 @@
 const os = require('os');
 const path = require('path');
-const readline = require('readline');
 
 const fs = require('fs').promises;
 const { bold } = require('../util/term');
@@ -11,24 +10,6 @@ const gitUtil = require('../util/git');
 const CDSRC_FILENAME = '.cdsrc-private.json';
 
 class UserCdsrcJsonStorageProvider {
-    async askBooleanQuestion(question) {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-
-        question = question.trim() + ' ';
-        return new Promise(resolve => {
-            rl.question(question, answer => {
-                if (answer === 'y' || answer === 'Y') {
-                    resolve(true);
-                } else {
-                    resolve(false);
-                }
-                rl.close();
-            });
-        });
-    }
 
     async storeServices(services, options = {}) {
         let jsonPath = options.out || CDSRC_FILENAME;

package/lib/build/buildTaskEngine.js

@@ -2,7 +2,7 @@ const fs = require('fs')
 const path = require('path')
 const cds = require('../cds'), { _log: log } = cds
 const { sortMessagesSeverityAware, deduplicateMessages, CompilationError } = cds.compiler
-const { relativePaths, BuildError, resolveRequiredSapModels, redactCredentials } = require('./util')
+const { relativePaths, BuildError, BuildMessage, resolveRequiredSapModels, redactCredentials } = require('./util')
 const { SEVERITIES, LOG_LEVELS } = require('./constants')
 const BuildTaskFactory = require('./buildTaskFactory')
 const InternalBuildPlugin = require('./provider/internalBuildPlugin')
@@ -39,7 +39,7 @@ class BuildTaskEngine {
         // validate required @sap namespace models - log only
         const unresolved = BuildTaskEngine._resolveRequiredSapServices(tasks)
         if (unresolved.length > 0) {
-            throw new BuildError(`Required CDS models [${unresolved.join(', ')}] cannot be resolved. Use the 'npm install' command to install up-to-date versions of the missing packages.`)
+            throw new BuildError(`Required CDS models [${unresolved.join(', ')}] cannot be resolved. Run the 'npm install' command to install up-to-date versions of the missing packages.`)
         }
 
         // create build plugins
@@ -187,8 +187,8 @@ class BuildTaskEngine {
         if (errors.length > 0) {
             const error = errors.find(e => e.constructor.name !== COMPILATION_ERROR)
             if (error) {
-                // throw original error, including BuildErrors
-                // for BuildErrors we do not merge other build messages that might exist in order to keep the original error intact
+                // throw original BuildError including existing BuildMessages
+                error.messages = this._sortMessagesUnique(pluginMessages.filter(m => m instanceof BuildMessage), error.messages)
                 throw error
             }
 

package/lib/build/provider/hana/2migration.js

@@ -7,15 +7,15 @@ const cdscVersion = `-- generated by cds-compiler version ${cdsc.version()}`
 const { getArtifactCdsPersistenceName } = cdsc
 const LOG = cds.log('cli|build'), DEBUG = cds.debug('cli|build')
 
-module.exports = async (model, beforeImage, srcPath, options = {}) => {
-    const { definitions, migrations, afterImage, journalFileNames } = _compileToHana(model, options, beforeImage)
+async function compileToHdbMigration(model, beforeImage, srcPath, options = {}) {
+    const { definitions, migrations, afterImage, migrationTableNames } = _compileToHana(model, options, beforeImage)
     const definitionResult = []
 
     for (const { name, suffix, sql } of definitions) {
         let definitionEntry = { name, suffix, content: sql }
 
         if (suffix === '.hdbtable') {
-            if (journalFileNames.has(name)) {
+            if (migrationTableNames.has(name)) {
                 const migration = migrations.find(migration => migration.name === name)
                 definitionEntry = await _2migrationtable(srcPath, migration || _emptyMigration(name), sql)
             }
@@ -27,6 +27,22 @@ module.exports = async (model, beforeImage, srcPath, options = {}) => {
     return { definitions: definitionResult, afterImage }
 }
 
+function getJournalEntities(model, options = {}) {
+    return cds.reflect(model).all(item => {
+        if (item.kind === 'entity' && item['@cds.persistence.journal'] === true) {
+            if (item['@cds.persistence.skip'] === true || item['@cds.persistence.exists'] === true) {
+                options.messages?.push(new BuildMessage(`[hdbmigrationtable] annotation @cds.persistence.journal skipped for entity '${item.name}' as persistence exists`, SEVERITY_WARNING))
+            }
+            return true
+        }
+        return false
+    })
+}
+
+function getMigrationTableName(entity, model) {
+    return getArtifactCdsPersistenceName(entity.name, 'quoted', model, 'hana')
+}
+
 function _compileToHana(model, options, beforeImage) {
     let definitions = []
     let migrations = []
@@ -58,20 +74,20 @@ function _compileToHana(model, options, beforeImage) {
         migrations = result.migrations
         afterImage = result.afterImage
     }
-    let journalFileNames = new Set()
+    let migrationTableNames = new Set()
     if (afterImage) {
         // 1. determine journal file names before _filterJournalArtifacts is called as getArtifactCdsPersistenceName
         // might no longer return the proper file name for the reduced CSN, e.g. for draft entities
-        journalFileNames = _getJournalFileNames(afterImage, options)
+        migrationTableNames = _getMigrationTableNames(afterImage, options)
 
         // 2. leave only persisted journal-related entities in afterImage
         afterImage = _filterJournalArtifacts(afterImage)
     }
 
-    _debug(definitions, migrations, journalFileNames)
+    _debug(definitions, migrations, migrationTableNames)
 
     return {
-        definitions, migrations, afterImage, journalFileNames
+        definitions, migrations, afterImage, migrationTableNames
     }
 }
 
@@ -158,21 +174,13 @@ function _emptyMigration(name) {
     return { name, suffix: ".hdbmigrationtable", changeset: [] }
 }
 
-function _getJournalFileNames(model, options) {
-    const journalNames = new Set(cds.reflect(model).all(item => {
-        if (item.kind === 'entity' && item['@cds.persistence.journal'] === true) {
-            if (item['@cds.persistence.skip'] === true || item['@cds.persistence.exists'] === true) {
-                options.messages?.push(new BuildMessage(`[hdbmigrationtable] annotation @cds.persistence.journal skipped for entity '${item.name}' as persistence exists`, SEVERITY_WARNING))
-            }
-            return true
-        }
-        return false
-    }).map(entity => getArtifactCdsPersistenceName(entity.name, 'quoted', model, 'hana')))
+function _getMigrationTableNames(model, options) {
+    const migrationTableNames = getJournalEntities(model, options).map(entity => getMigrationTableName(entity, model))
 
-    DEBUG?.(`\n[hdbmigrationtable] found ${journalNames.size} model entities annotated with '@cds.persistence.journal`)
-    DEBUG?.(`[hdbmigrationtable] ${[...journalNames].join(', ')}\n`)
+    DEBUG?.(`\n[hdbmigrationtable] found ${migrationTableNames.length} model entities annotated with '@cds.persistence.journal`)
+    DEBUG?.(`[hdbmigrationtable] ${migrationTableNames.join(', ')}\n`)
 
-    return journalNames
+    return new Set(migrationTableNames)
 }
 
 // only keep journal related entities
@@ -217,3 +225,9 @@ ${migration ? migration.changeset.map(change => change.sql).join('\n') : 'Empty
         }
     }
 }
+
+module.exports = {
+    compileToHdbMigration,
+    getJournalEntities,
+    getMigrationTableName
+}