@sap/cds-dk 9.7.2 → 9.8.1

package/lib/build/{plugin.js → plugins/plugin.js}

@@ -1,13 +1,13 @@
 const path = require('node:path')
 const fs = require('node:fs')
 const os = require('node:os');
-const cds = require('../cds')
+const cds = require('../../cds')
 const IS_WIN = os.platform() === 'win32';
 
-const { OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, SEVERITY_INFO, SEVERITY_WARNING, SEVERITY_ERROR } = require('./constants')
+const { SEVERITY_INFO, SEVERITY_WARNING, SEVERITY_ERROR } = require('../constants')
 
-const { find } = require('../util/fs')
-const { hasOptionValue, relativePaths, BuildMessage, filterFeaturePaths } = require('./util')
+const { find } = require('../../util/fs')
+const { hasOptionValue, relativePaths, BuildMessage, filterFeaturePaths } = require('../util')
 
 const DEBUG = cds.debug('cli|build')
 
@@ -28,18 +28,17 @@ const DEBUG = cds.debug('cli|build')
  * the fully qualified node module path of the build plugin implementation.
  * The build task engine defines the following protocol. The methods are invoked in descending order:
  *  - `init()` - optional
- *  - `get priority()` - optional
  *  - `async clean()`
  *  - `async build()`
  * The reflected CSN can be accessed using the async method `model()`.
  */
-class Plugin {
+module.exports = class Plugin {
     static INFO = SEVERITY_INFO
     static WARNING = SEVERITY_WARNING
     static ERROR = SEVERITY_ERROR
 
     /** @type {TaskDefaults} */
-    static taskDefaults  // injected externally
+    taskDefaults  // injected externally
 
     /**
      * @type {Task | undefined}
@@ -103,17 +102,7 @@ class Plugin {
         return this._context
     }
 
-    /**
-     * Returns the priority of this plugin as number, where 1024 represents the default value
-     * to ensure that custom plugins are by default executed before the built-in plugins.
-     * The higher the priority value, the sooner the build plugin will be run.
-     * The range of valid priority values is from -1024 to +1024.
-     * Built-in plugins have a priority value range from 0 - 524.
-     * @returns the priority for this plugin as integer.
-     */
-    get priority() {
-        return 1024
-    }
+    get requires() { return [] }
 
     /**
      * Called by the framework immediately after this instance has been created.
@@ -133,7 +122,7 @@ class Plugin {
 
     /**
      * Called by the framework immediately before 'build' to delete any output created by this build plugin.
-     * Note: The [`BuildTaskEngine`]({@link ./buildTaskEngine.js)}) is cleaning the common generation target folder if the build is
+     * Note: The common generation target folder is cleaned by default if the build is
      * executed in staging mode, e.g. build.target: "gen".
      */
     async clean() {
@@ -162,15 +151,13 @@ class Plugin {
     write(data) {
         return {
             to: async (/** @type {string} */ dest) => {
-                if (this._hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM)) {
-                    if (!path.isAbsolute(dest)) {
-                        // relative to build task's destination path
-                        dest = path.resolve(this.task.dest, dest)
-                    }
-                    this.pushFile(dest)
-                    await fs.promises.mkdir(path.dirname(dest), { recursive: true })
-                    await fs.promises.writeFile(dest, typeof data === "object" && !Buffer.isBuffer(data) ? JSON.stringify(data, null, 2) : data)
+                if (!path.isAbsolute(dest)) {
+                    // relative to build task's destination path
+                    dest = path.resolve(this.task.dest, dest)
                 }
+                this.pushFile(dest)
+                await fs.promises.mkdir(path.dirname(dest), { recursive: true })
+                await fs.promises.writeFile(dest, typeof data === "object" && !Buffer.isBuffer(data) ? JSON.stringify(data, null, 2) : data)
             }
         }
     }
@@ -188,28 +175,26 @@ class Plugin {
     copy(src) {
         return {
             to: async (/** @type {string} */ dest) => {
-                if (this._hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM)) {
-                    if (!path.isAbsolute(src)) {
-                        // relative to build task's source path
-                        src = path.resolve(this.task.src, src)
-                    }
-                    if (!path.isAbsolute(dest)) {
-                        // relative to build task's destination path
-                        dest = path.resolve(this.task.dest, dest)
-                    }
-                    // list all copied files recursively
-                    if (cds.utils.isdir(src)) {
-                        await fs.promises.cp(src, dest, { recursive: true })
-                        const files = await find(dest)
-                        files.forEach(file => this.pushFile(file))
-                    } else {
-                        this.pushFile(dest)
-                        if (IS_WIN && fs.lstatSync(src).isSymbolicLink()) {
-                            const linkTarget = await fs.promises.readlink(src);
-                            src = path.resolve(path.dirname(src), linkTarget);
-                        }
-                        return fs.promises.cp(src, dest, { recursive: true })
+                if (!path.isAbsolute(src)) {
+                    // relative to build task's source path
+                    src = path.resolve(this.task.src, src)
+                }
+                if (!path.isAbsolute(dest)) {
+                    // relative to build task's destination path
+                    dest = path.resolve(this.task.dest, dest)
+                }
+                // list all copied files recursively
+                if (cds.utils.isdir(src)) {
+                    await fs.promises.cp(src, dest, { recursive: true })
+                    const files = await find(dest)
+                    files.forEach(file => this.pushFile(file))
+                } else {
+                    this.pushFile(dest)
+                    if (IS_WIN && fs.lstatSync(src).isSymbolicLink()) {
+                        const linkTarget = await fs.promises.readlink(src);
+                        src = path.resolve(path.dirname(src), linkTarget);
                     }
+                    return fs.promises.cp(src, dest, { recursive: true })
                 }
             }
         }
@@ -221,7 +206,7 @@ class Plugin {
      * User messages will be logged after CDS build has been finished based on the log-level that has been set.
      * By default messages with severity <em>warning</em> and <em>error</em> will be logged.
      * @param {string} message - the message text
-     * @param {import('./constants').Severity} severity - the severity of the message
+     * @param {import('../constants').Severity} severity - the severity of the message
      */
     pushMessage(message, severity) {
         this.messages.push(new BuildMessage(message, severity))
@@ -233,21 +218,23 @@ class Plugin {
      * @returns {Promise<import('@sap/cds').csn.CSN | null>} the compiled CSN model
      */
     async model() {
-        const files = cds.resolve(this.task.options.model || this.task.src)
-
+        const { src, options: { model }, for: type } = this.task
+        const files = cds.resolve(model || src)
         if (!files || files.length === 0) {
-            console.log(`no CDS model found for [${this.task.for}] build task [${this.task.src}] - nothing to be done`)
-            return null
+            console.log(`no CDS model found for [${type}] build task [${src}] - nothing to be done`)
+            return
         }
         DEBUG?.(`model: ${relativePaths(cds.root, files).join(", ")}`)
-        // $location paths are relative to current working dir by default - make sure a given project root folder is taken
+
         const options = { ...this.options(), cwd: cds.root }
 
-        const model = await cds.load(files, options)
-        if (!model) {
-            return null
+        this.context._modelCache ??= new Map()
+        const cacheKey = JSON.stringify({ files, options })
+        if (!this.context._modelCache.has(cacheKey)) {
+            const _load = cds.load(files, options)
+            this.context._modelCache.set(cacheKey, _load)
         }
-        return model
+        return this.context._modelCache.get(cacheKey)
     }
 
     /**
@@ -261,7 +248,18 @@ class Plugin {
             return model
         }
         const sources = filterFeaturePaths(model, this.task.options.model || this.task.src)
-        return sources.features ? cds.load(sources.base, this.options()) : model
+        if (!sources.features) {
+            return model
+        }
+
+        const options = this.options()
+        this.context._modelCache ??= new Map()
+        const cacheKey = JSON.stringify({ files: sources.base, options })
+        if (!this.context._modelCache.has(cacheKey)) {
+            const _load = cds.load(sources.base, options)
+            this.context._modelCache.set(cacheKey, _load)
+        }
+        return this.context._modelCache.get(cacheKey)
     }
 
     options() {
@@ -293,4 +291,3 @@ class Plugin {
         return value
     }
 }
-module.exports = Plugin

package/lib/build/plugins.js

@@ -1,22 +1,20 @@
 // @ts-check
 const cds = require('../cds')
+const { isdir, fs, path } = cds.utils
 const DEBUG = cds.debug('cli|build')
 
-/** @typedef {typeof import('./plugin')} BuildPlugin */
+/** @typedef {typeof import('./plugins/plugin')} BuildPlugin */
 
 module.exports = new (class Plugins {
 
     /** @type {Map<string, BuildPlugin>} */
     #plugins = new Map()
+    #registeredDefaults = false
 
-    get plugins() {
+    get all() {
         return this.#plugins
     }
 
-    constructor() {
-        this.#registerDefaults()
-    }
-
     /**
      * @param {string} id - unique ID of the plugin
      * @param {BuildPlugin} plugin - build plugin implementation
@@ -32,7 +30,12 @@ module.exports = new (class Plugins {
         this.#plugins.set(id, plugin)
     }
 
-    #registerDefaults() {
-        this.register('helm', require('./plugins/helm'))
+    registerDefaults() {
+        if (this.#registeredDefaults) return
+        const plugins = fs.readdirSync(path.join(__dirname, 'plugins'))
+        for (const plugin of plugins) if (isdir(__dirname, 'plugins', plugin)) {
+            this.register(plugin, require(`./plugins/${plugin}`))
+        }
+        this.#registeredDefaults = true
     }
 })

package/lib/build/util.js

@@ -21,13 +21,6 @@ const FLATTEN_MAX_DEPTH = 20 // should suffice, was infinite in earlier versions
 /** @typedef {object[] | object} Credentials */
 /** @typedef {(string | NestedStringArray)[]} NestedStringArray */
 
-/**
- * Returns whether this project is a java project or not.
-*/
-function hasJavaNature() {
-    return [cds.env.folders.srv, '.'].some(f => f && fs.existsSync(path.join(cds.root, f, 'pom.xml')))
-}
-
 /**
  * Determines whether the both values are identical.
  * @template {number | boolean} T
@@ -494,7 +487,6 @@ class BuildError extends Error {
 }
 
 module.exports = {
-    hasJavaNature,
     hasOptionValue,
     relativePaths,
     resolveRequiredSapModels,

package/lib/compile/to-xsuaa.js

@@ -158,10 +158,10 @@ function getBaseModel(options = {}) {
   if (typeof options.base === 'string') {
     try {
       return JSON.parse(options.base) // plain object
-    } catch (err) {
+    } catch {
       try {
         return JSON.parse(fs.readFileSync(path.resolve(options.base))); // file
-      } catch (err2) {
+      } catch {
         throw new Error('Neither a JSON object nor a file path: ' + options.base)
       }
     }

package/lib/deploy/to-hana/hana.js

@@ -11,8 +11,8 @@ const mtaUtil = require('./mtaUtil');
 
 const { bold, info, warn } = require('../../util/term');
 
-const { bind, storeBindings } = require('../../bind/shared');
-const { BUILD_TASK_HANA, OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, OUTPUT_MODE_RESULT } = require('../../build/constants');
+const { bind, storeBindings, env: bindingEnv } = require('../../bind/shared');
+const { BUILD_TASK_HANA } = require('../../build/constants');
 
 const { options, flags } = require('../index');
 const allOptions = [...options, ...flags];
@@ -43,7 +43,7 @@ module.exports = new class HanaDeployer {
       if (process.env[varName]) {
         try {
           result[varName] = JSON.parse(process.env[varName]);
-        } catch (err) {
+        } catch {
           throw new Error(`Error parsing environment variable ${varName}`);
         }
       }
@@ -52,6 +52,9 @@ module.exports = new class HanaDeployer {
   }
 
   async deploy(options = {}) {
+    if (options['store-credentials']) {
+      console.warn(warn('The option \'--store-credentials\' has been deprecated and will be removed with the next major release. Use command \'cds bind\' instead.'));
+    }
 
     if (options.dry && options.out) { // dry run equals cds compile to hana
       return await this._runCompileToHana(options);
@@ -92,11 +95,10 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
       }
     }
 
-    let buildResult
     if (cds.cli.options?.['no-build']) {
       console.log(`Provided flag '--no-build', skipping cds build`)
     } else {
-      buildResult = await this._build();
+      await build({ for: BUILD_TASK_HANA });
     }
 
     if (options.out) {
@@ -112,7 +114,6 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     }
 
     // the primary database is always built and deployed
-    // const dest = buildResult.dest
     const dest = path.join(cds.root, cds.env.build.target, cds.env.folders.db);
 
     if (undeployWhitelist) {
@@ -123,56 +124,78 @@ Therefore, specifying the CDS model is not required when calling 'cds deploy'.`;
     const hasVCAPEnv = Object.keys(vcapEnv).length > 0;
 
     let bindOptions
-    if (cds.cli.options.on === 'k8s') {
+    let usesExistingK8sBinding = false
+
+    const { readProject } = require('../../init/projectReader')
+    const { hasKyma, hasMta } = readProject()
+    const onKyma = cds.cli.options.on === 'k8s'  || (hasKyma && !hasMta && cds.cli.options.on !== 'cf')
+    if (onKyma) {
       const cp = require('node:child_process')
-      const appName = pServiceName ?? path.basename(cds.root)
-      const instance =
+
+      const existing = cds.requires.db?.binding
+      if (!pServiceName && existing && (existing.name || existing.secret)) {
+        const envVars = await bindingEnv({ env: cds.env, silent: true })
+        if (envVars?.VCAP_SERVICES) {
+          vcapEnv.VCAP_SERVICES = JSON.parse(envVars.VCAP_SERVICES)
+          usesExistingK8sBinding = true
+          console.log(`using existing Kubernetes binding ${bold(existing.name || existing.secret)}`)
+        }
+      }
+
+      if (!usesExistingK8sBinding) {
+        const baseName = pServiceName ?? path.basename(cds.root)
+        const instanceName = baseName.endsWith('-db') ? baseName : `${baseName}-db`
+        const bindingName = `${instanceName}-binding`
+        const secretName = `${instanceName}-secret`
+
+        const instance =
 `apiVersion: services.cloud.sap.com/v1
 kind: ServiceInstance
 metadata:
-  name: ${appName}-db
+  name: ${instanceName}
 spec:
   serviceOfferingName: hana
   servicePlanName: hdi-shared
 `
 
-      const binding =
+        const binding =
 `apiVersion: services.cloud.sap.com/v1
 kind: ServiceBinding
 metadata:
-  name: ${appName}-db-binding
+  name: ${bindingName}
 spec:
-  serviceInstanceName: ${appName}-db
-  secretName: ${appName}-db-secret
+  serviceInstanceName: ${instanceName}
+  secretName: ${secretName}
 `
 
-      try {
-        cp.execSync('kubectl apply -f -', { input: instance })
-        cp.execSync('kubectl apply -f -', { input: binding })
-        cp.execSync(`kubectl wait --for=condition=Ready servicebinding/${appName}-db-binding --timeout=180s`)
-        cp.execSync(`kubectl wait --for=condition=Ready serviceinstance/${appName}-db --timeout=180s`)
-      } catch (error) {
-        const descr = cp.execSync(`kubectl describe serviceinstance/${appName}-db`).toString()
-        const message = descr.match(/Message:\s+(.*)/)?.[1] || 'None'
-        throw error.message + `\nInstance Message: ${message}`
-      }
+        try {
+          cp.execSync('kubectl apply -f -', { input: instance })
+          cp.execSync('kubectl apply -f -', { input: binding })
+          cp.execSync(`kubectl wait --for=condition=Ready servicebinding/${bindingName} --timeout=180s`)
+          cp.execSync(`kubectl wait --for=condition=Ready serviceinstance/${instanceName} --timeout=180s`)
+        } catch (error) {
+          const descr = cp.execSync(`kubectl describe serviceinstance/${instanceName}`).toString()
+          const message = descr.match(/Message:\s+(.*)/)?.[1] || 'None'
+          throw error.message + `\nInstance Message: ${message}`
+        }
 
-      const { data: encoded } = JSON.parse(cp.execSync(`kubectl get secrets/${appName}-db-secret -o json`).toString())
-      const credentials = {}
-      for (const [key, value] of Object.entries(encoded)) {
-        credentials[key] = Buffer.from(value, 'base64').toString('utf-8');
-      }
-      vcapEnv.VCAP_SERVICES ??= {
-        hana: [{
-          tags: ['hana'],
-          credentials
-        }]
-      }
-      bindOptions = {
-        ...options,
-        to: `${appName}-db-binding`,
-        for: options.for,
-        kind: BUILD_TASK_HANA
+        const { data: encoded } = JSON.parse(cp.execSync(`kubectl get secrets/${secretName} -o json`).toString())
+        const credentials = {}
+        for (const [key, value] of Object.entries(encoded)) {
+          credentials[key] = Buffer.from(value, 'base64').toString('utf-8');
+        }
+        vcapEnv.VCAP_SERVICES ??= {
+          hana: [{
+            tags: ['hana'],
+            credentials
+          }]
+        }
+        bindOptions = {
+          ...options,
+          to: `${bindingName}`,
+          for: options.for,
+          kind: BUILD_TASK_HANA
+        }
       }
     } else {
       let serviceName = pServiceName;
@@ -223,7 +246,7 @@ spec:
     DEBUG?.({ dest, vcapEnv, hdiOptions })
     await hdi.deploy(dest, vcapEnv, hdiOptions);
 
-    if (!hasVCAPEnv) {
+    if (!hasVCAPEnv && !usesExistingK8sBinding) {
       const services = await bind(bindOptions)
       await storeBindings(services, bindOptions)
     }
@@ -239,8 +262,6 @@ spec:
       console.warn(warn('\nWARNING:'));
       console.warn(warn(warnings.join('\n')));
     }
-
-    return buildResult;
   }
 
   async _runCompileToHana(options) {
@@ -307,19 +328,6 @@ spec:
     }
   }
 
-
-  async _build() {
-    const buildTaskOptions = {
-      for: BUILD_TASK_HANA,
-      // src: cds.env.folders.db,
-      [OUTPUT_MODE]: OUTPUT_MODE_FILESYSTEM | OUTPUT_MODE_RESULT
-    }
-
-    // cds build throws an error if the src folder does not exist
-    const buildResult = await build(buildTaskOptions);
-    return buildResult[0].result;
-  }
-
   _injectTunnelAddress(credentials, tunnelAddress) {
     if (!/\w+:\d+/.test(tunnelAddress)) {
       throw `Invalid tunnel address '${tunnelAddress}' - must be in form 'host:port'`;

package/lib/import/common.js

@@ -35,7 +35,7 @@ async function _isValidXML(edmx) {
     try {
         generateEDMX2JSON(edmx);
         isValid = true;
-    } catch (err) {
+    } catch {
         isValid = false;
     }
     return isValid;

package/lib/import/odata/metadataconverter/MetadataConverter.js

@@ -1621,10 +1621,11 @@ class PropertyPathExpression extends Expression {
         if (targetOption === MetadataConverter.TARGETS.LIBRARY) {
             target = { [this._targetName]: this.getElement().elements[0].text };
         } else if (!this.getElement().elements && this._targetName === '$NavigationPropertyPath') {
-            //elements are not given, when <NavigationPropertyPath/> is in EDMX, which is used to refresh the current context
+            // elements are not given, when <NavigationPropertyPath/> is in EDMX, which is used to refresh the current context
+            // OData tsc decided this should now be represented with a null value
             return {
-                "=": "($self)"
-            };
+                "=": '(null)'
+            };;
         } else {
             target = this.getElement().elements[0].text;
         }