@sap/cds-dk 6.5.2 → 6.6.1

package/lib/init/template/samples/index.js

@@ -6,12 +6,10 @@ const term = require('../../../util/term');
 const { PROJECT_TYPE, OPTION_JAVA, URLS } = require('../../constants');
 
 module.exports = class SamplesTemplate extends require('../templateBase') {
-    constructor(projectPath, generator) {
-        super(projectPath, generator, __dirname);
-    }
+
 
     async run() {
-        switch (await this.getProjectType()) {
+        switch (this.getProjectType()) {
             case PROJECT_TYPE.java:
                 return await this._addJavaSamples();
 
@@ -49,16 +47,13 @@ module.exports = class SamplesTemplate extends require('../templateBase') {
     }
 
     async _addNodejsSamples() {
-        const folders = (await this.getEnv()).folders;
-        const dbFolder = join(this.projectPath, folders.db);
+        const { db, srv } = (await this.getEnv()).folders;
+        const dbFolder = join(this.projectPath, db);
         await copyFiles(join(__dirname, 'files', 'nodejs', 'db'), dbFolder, {}, this.options.force);
 
-        const srvFolder = join(this.projectPath, folders.srv);
+        const srvFolder = join(this.projectPath, srv);
         await copyFiles(join(__dirname, 'files', 'nodejs', 'srv'), srvFolder, {
-            dbFolder: folders.db.replace(/[\\/]+$/, '')
+            dbFolder: db.replace(/[\\/]+$/, '')
         }, this.options.force);
     }
-
-    async finalize() {
-    }
 }

package/lib/init/template/templateBase.js

@@ -8,19 +8,18 @@ module.exports = class TemplateBase {
     /**
      * @constructor
      */
-    constructor(projectPath, generator, dirName) {
-        if (generator.options && generator.options.for && typeof generator.options.for !== 'string') {
+    constructor(generator) {
+        if (generator.options?.for && typeof generator.options?.for !== 'string') {
             throw new Error('The --for argument must not be empty.')
         }
-        this.projectPath = path.resolve(projectPath);
+        this.projectPath = cds.root;
         this.options = generator.options || {};
-        this.projectPath = path.resolve(projectPath);
         this.generator = generator;
+        this.name = this.constructor.name.replace(/template/i, '').replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
 
         this.cwd = this.options.cwd || process.cwd();
-        this.name = (dirName ? path.basename(dirName) : this.constructor.name.replace(/template/i, '').toLowerCase());
 
-        this.projectName = path.basename(this.projectPath);
+        this.projectName = path.basename(cds.root);
     }
 
     /**
@@ -40,7 +39,7 @@ module.exports = class TemplateBase {
     }
 
     // eslint-disable-next-line no-unused-vars
-    static hasFacet(env, projectPath, options) {
+    static hasFacet(env, options) {
         return true;
     }
 
@@ -52,7 +51,7 @@ module.exports = class TemplateBase {
         const cdsEnvVar = process.env.CDS_ENV
         process.env.CDS_ENV = profile
         try {
-            return cds.env.for('cds', exists(this.projectPath) ? this.projectPath : this.cwd);
+            return cds.env.for('cds');
         } finally {
             cdsEnvVar ? process.env.CDS_ENV = cdsEnvVar : delete process.env.CDS_ENV
         }
@@ -93,15 +92,9 @@ module.exports = class TemplateBase {
      * @see PROJECT_TYPE
      * @returns PROJECT_TYPE for current project
      */
-    async getProjectType() {
-        if (exists(path.join(this.projectPath, 'pom.xml'))) {
-            return PROJECT_TYPE.java;
-        }
-
-        if (exists(path.join(this.projectPath, 'package.json'))) {
-            return PROJECT_TYPE.nodejs;
-        }
-
+    getProjectType() {
+        if (exists('pom.xml')) return PROJECT_TYPE.java;
+        if (exists('package.json')) return PROJECT_TYPE.nodejs;
         return PROJECT_TYPE.unknown;
     }
 }

package/lib/init/template/toggles/index.js

@@ -1,19 +1,15 @@
 const { join } = require('path')
-const ProjectReader = require('../../util/projectReader')
+const { readProject } = require('../../util/projectReader')
 const { mergeJSON, sortDependencies } = require('../../util/merge')
 
 module.exports = class TogglesTemplate extends require('../templateBase') {
-  constructor(projectPath, generator) {
-    super(projectPath, generator, __dirname)
-    this.projectReader = new ProjectReader(projectPath)
-  }
 
   static hasFacet(env) {
     return !!env.requires?.toggles
   }
 
   async run() {
-    const projectDescriptor = await this.projectReader.read(this.options)
+    const projectDescriptor = await readProject(this.options)
     const { for: forProfile, isNodejs, isJava } = projectDescriptor.cap
     if (isNodejs) {
       const packageJSONPath = join(this.projectPath, 'package.json')

package/lib/init/template/xsuaa/files/values.yaml.hbs

@@ -28,4 +28,3 @@ xsuaa:
       redirect-uris:
       - https://*.<your-cluster-domain>/**
 {{/cap.hasApprouter}}
-  config: xs-security.json

package/lib/init/template/xsuaa/files/xsuaa.yaml

@@ -1 +1,4 @@
-{{- include "cap.service-instance" . }}
+dependencies:
+  - name: service-instance
+    alias: xsuaa
+    version: 0.1.0

package/lib/init/template/xsuaa/index.js

@@ -1,15 +1,11 @@
 const { join } = require('path')
-const ProjectReader = require('../../util/projectReader')
+const { readProject } = require('../../util/projectReader')
 const { mergeJSON, mergeYAML } = require('../../util/merge')
-const { copyAndTrack, parseMd5File, writeMd5File } = require('../../util/md5Tracking')
+const { parseMd5File, writeMd5File } = require('../../util/md5Tracking')
 const { srvNode, srvJava, xsuaa, mtxSidecar } = require('../_merging/registry-mta')
 const { PROJECT_TYPE } = require('../../constants')
 
 module.exports = class XsuaaTemplate extends require('../templateBase') {
-    constructor(projectPath, generator) {
-        super(projectPath, generator, __dirname)
-        this.projectReader = new ProjectReader(projectPath)
-    }
 
     static hasFacet(env) {
         return env.requires?.auth?.kind === 'xsuaa'
@@ -18,8 +14,8 @@ module.exports = class XsuaaTemplate extends require('../templateBase') {
     async run() {
         const { projectPath } = this
         const templatePath = join(__dirname, 'files')
-        const projectDescriptor = await this.projectReader.read(this.options)
-        const projectType = await this.getProjectType();
+        const projectDescriptor = await readProject(this.options)
+        const projectType = this.getProjectType();
         const { for: forProfile } = projectDescriptor.cap
 
         if (projectType === PROJECT_TYPE.java) {
@@ -40,7 +36,7 @@ module.exports = class XsuaaTemplate extends require('../templateBase') {
     }
 
     async runDependentMerging( context = {}) {
-        const projectDescriptor = await this.projectReader.read(this.options)
+        const projectDescriptor = await readProject(this.options)
         const { isMultitenant, isExtensible, hasMta, hasHelm, isNodejs, isJava } = projectDescriptor.cap
 
         const cds = require('../../../../lib/compile')
@@ -50,7 +46,6 @@ module.exports = class XsuaaTemplate extends require('../templateBase') {
         } catch (error) { /* ignore */ }
         })() || { scopes: [], attributes: [], 'role-templates': [], 'authorities-inheritance': false }
         const mergingSemantics = { additions: xsSecurity.scopes.map(scope => ({
-            ref: scope.name,
             in: 'scopes',
             where: [{
                 property: 'name',
@@ -77,7 +72,7 @@ module.exports = class XsuaaTemplate extends require('../templateBase') {
 
             await mergeYAML(
                 mtaYAMLPath,
-                `${__dirname}/files/mta.yaml.hbs`,
+                join(__dirname, 'files', 'mta.yaml.hbs'),
                 projectDescriptor,
                 {
                     additions,
@@ -94,22 +89,31 @@ module.exports = class XsuaaTemplate extends require('../templateBase') {
                 context.projectPath = this.projectPath;
                 context.oldTrackingData = context.newTrackingData = await parseMd5File(join(this.projectPath, 'chart', '.cds-add-helm-files.md5'));
             }
-            await copyAndTrack(
+            
+            // copy service-instance chart
+            const HelmTemplate = require(`../helm`);
+            const helmTemplate = new HelmTemplate(this.generator, context.oldTrackingData, context.newTrackingData);
+            isIndependentCommand = isIndependentCommand | await helmTemplate.addSubChart('service-instance');
+
+            // add dependency entry in chart.yaml
+            await mergeYAML(
+                join(this.projectPath, 'chart', 'Chart.yaml'),
                 join(__dirname, 'files', 'xsuaa.yaml'),
-                join(this.projectPath, 'chart', 'templates', 'xsuaa.yaml'),
-                context
-            )
+                projectDescriptor,
+                { additions: [{
+                    in: `dependencies`,
+                    where: [{
+                        property: 'alias',
+                        isEqualTo: 'xsuaa'
+                    }]
+                }]}
+            );
+
             await mergeYAML(
                 join(this.projectPath, 'chart', 'values.yaml'),
                 join(__dirname, 'files', 'values.yaml.hbs'),
                 projectDescriptor
             )
-            // REVISIT: Shared xs-security.json location for Helm and MTA?
-            await copyAndTrack(
-                join(this.projectPath, 'xs-security.json'),
-                join(this.projectPath, 'chart', 'xs-security.json'),
-                context
-            )
             if(isIndependentCommand) await writeMd5File(join(this.projectPath, 'chart', '.cds-add-helm-files.md5'), context.newTrackingData);
         }
 
@@ -118,13 +122,13 @@ module.exports = class XsuaaTemplate extends require('../templateBase') {
         // TODO: Find a generic solution for situation like these.
         if (isMultitenant) {
             const MultitenancyTemplate = require(`../multitenancy`)
-            const multitenancyTemplate = new MultitenancyTemplate(this.projectPath, this.generator)
+            const multitenancyTemplate = new MultitenancyTemplate(this.generator)
             await multitenancyTemplate.runDependentMerging(context)
         }
 
         if (isExtensible) {
             const ExtensibilityTemplate = require(`../extensibility`)
-            const extensibilityTemplate = new ExtensibilityTemplate(this.projectPath, this.generator)
+            const extensibilityTemplate = new ExtensibilityTemplate(this.generator)
             await extensibilityTemplate.runDependentMerging(context)
         }
     }

package/lib/init/types.d.ts

@@ -27,84 +27,3 @@ export interface CDSGenerator {
    */
   uiConfig?: any;
 }
-
-/**
- * This is a helper interface to provide support for different file system implementations.
- * Depending on the scenario different file systems will be used, e.g. Yeoman vs. native FS.
- */
-export interface FsUtil {
-  /**
-   * Writes the given string into a file.
-   * @param filepath the absolute file path
-   * @param content the string to serialize to JSON
-   */
-  writeFile(filePath: string, content: string, skipLogFile?: boolean): Promise<void>;
-
-  /**
-   * Writes the given object as JSON into a file.
-   * @param filepath the absolute file path
-   * @param object the object to serialize to JSON
-   */
-  writeJSON(filepath: string, object: any, options?: any): Promise<void>;
-
-  /**
-   * Writes YAML object
-   * @param filepath the absolute file path
-   * @param yaml the yaml object
-   * @param skipFileLog do not log files if true
-   */
-  writeYAML(filepath: string, yaml: any, skipFileLog?: boolean): Promise<void>;
-
-  /**
-   * Reads a file from given path.
-   * @param filePath the absolute file path
-   * @param options optional read options
-   * @returns the file content as string
-   */
-  readFile(filePath: string, options?: any): Promise<string>;
-
-  /**
-   * Reads a JSON object from a file.
-   * @param filePath the absolute file path
-   * @param projectDescriptor a project descriptor
-   * @returns the file content as object
-   */
-  readJSON(filePath: string, projectDescriptor: any): Promise<any>;
-
-  /**
-   * Reads a JSON object from a file.
-   * @param filePath the absolute file path
-   * @returns the file content as object
-   */
-  readJSONC(filePath: string): Promise<any>;
-
-  /**
-   * Reads a JSON object from a file.
-   * @param filePath the absolute file path
-   * @param projectDescriptor a project descriptor
-   * @returns the file content as yaml object
-   */
-  readYAML(filePath: string, projectDescriptor: any): Promise<any>;
-
-  /**
-  * Copies a file or folder from given source to destination.
-  * @param source the source path
-  * @param destination the destination path
-  * @param options optional copy options
-  * @param skipFileLog do not log files if true
-  */
-  copy(source: string, destination: string, options?: any, skipFileLog?: boolean): Promise<void>;
-}
-
-/**
- * Helper for managing npm related tasks
- * @deprecated
- */
-export interface NpmUtil {
-  /**
-   * Installs npm packages
-   * @param cwd working folder
-   * @param options npm install options, e.g. force
-   */
-  install(cwd?: string, options?: any): Promise<void>
-}

package/lib/init/util/merge.js

@@ -76,17 +76,17 @@ async function mergeYAML(into, from, projectDescriptor, semantics = {}) {
 
     const { additions, overwrites, deletions, relationships } = semantics
     additions?.forEach(existence => {
-        existenceMap.set(existence.ref, undefined)
-        templateExistenceMap.set(existence.ref, undefined)
+        existenceMap.set(existence, undefined)
+        templateExistenceMap.set(existence, undefined)
     })
     deletions?.forEach(deletion => {
-        existenceMap.set(deletion.item.ref, undefined)
+        existenceMap.set(deletion.item, undefined)
     })
     relationships?.forEach(relationship => {
         const [existence] = relationship.into
         const [insertExistence] = relationship.insert
-        const ref = insertExistence.ref + ' -> ' + existence.ref
-        existenceMap.set(ref, undefined)
+        const hash = insertExistence + ' -> ' + existence
+        existenceMap.set(hash, undefined)
     })
 
     let collectionStack = [target.contents]
@@ -99,17 +99,17 @@ async function mergeYAML(into, from, projectDescriptor, semantics = {}) {
                 let where = existence.in
                 if (typeof where === 'string') return true // just a key path on the document root
                 else where = where[0] // a more complex list of constraints, a sequence/array is involved
-                const neededParent = dict.get(where.ref)?.node
+                const neededParent = dict.get(where)?.node
                 return collectionStack.includes(neededParent) // lookbehind in parent collection stack
                 // REVISIT: Only look behind until sequence is reached?
-        }).forEach(({ where, ref }) => {
+        }).forEach(item => {
             const json = JSON.parse(String(node))
-            const whereFulfilled = where.every(constraint =>
+            const whereFulfilled = item.where.every(constraint =>
                 constraint.isEqualTo === _getProperty(json, constraint.property)
             )
             if (whereFulfilled) {
                 const [collection] = collectionStack
-                dict.set(ref, { json, node, index, collection })
+                dict.set(item, { json, node, index, collection })
             }
         })
         if (additions) _addToMap(additions)
@@ -212,7 +212,7 @@ async function mergeYAML(into, from, projectDescriptor, semantics = {}) {
     overwrites?.forEach(({ item, withValue }) => {
         const keyPath = Array.isArray(item) && typeof item[0] === 'string' ? item[0] : typeof item === 'string' ? item : item[1]
         const inExistence = Array.isArray(item) && typeof item[0] === 'object' ? item[0] : typeof item === 'object' ? item : item[1]
-        const node = inExistence && existenceMap.get(inExistence.ref) ? existenceMap.get(inExistence.ref).node : collectionStack[collectionStack.length - 1]
+        const node = inExistence && existenceMap.get(inExistence) ? existenceMap.get(inExistence).node : collectionStack[collectionStack.length - 1]
         const keys = keyPath.split('.')
         if (!node.getIn(keys)) return
         _getYAMLProperty(node, keys.slice(0, keys.length - 1).join('.'))
@@ -220,8 +220,8 @@ async function mergeYAML(into, from, projectDescriptor, semantics = {}) {
     })
 
     // 4. Delete existences from the project (e.g. separate deployer module when adding mtx)
-    deletions?.forEach(({ item: { ref }, relationships }) => {
-        const existence = existenceMap.get(ref)
+    deletions?.forEach(({ item, relationships }) => {
+        const existence = existenceMap.get(item)
         if (!existence) return
         existence.collection.delete(existence.index)
 
@@ -250,7 +250,7 @@ async function mergeYAML(into, from, projectDescriptor, semantics = {}) {
                 let [,parent] = collectionStack
                 additions?.filter(addition => {
                         if (typeof addition.in === 'string' || Array.isArray(addition.in) && typeof addition.in[0] === 'string') return true
-                        const inExistence = Array.isArray(addition.in) ? existenceMap.get(addition.in[0].ref) : existenceMap.get(addition.in.ref)
+                        const inExistence = Array.isArray(addition.in) ? existenceMap.get(addition.in[0]) : existenceMap.get(addition.in)
                         return inExistence?.node === parent
                     })
                     .filter(addition => {
@@ -260,12 +260,10 @@ async function mergeYAML(into, from, projectDescriptor, semantics = {}) {
                         if (keys.length > 1) parent = collectionStack[keys.length]
                         return _getYAMLProperty(parent, keyPath) === targetNode
                     })
-                    .filter(({ ref }) => {
-                        return !existenceMap.get(ref)
-                    })
-                    .forEach(({ ref, at }) => {
-                        const templateNode = templateExistenceMap.get(ref).node
-                        at !== undefined ? targetNode.items.splice(at, 0, templateNode) : targetNode.add(templateNode)
+                    .filter(item => !existenceMap.get(item))
+                    .forEach(item => {
+                        const templateNode = templateExistenceMap.get(item).node
+                        item.at !== undefined ? targetNode.items.splice(item.at, 0, templateNode) : targetNode.add(templateNode)
                     })
             }
         },
@@ -286,8 +284,8 @@ async function mergeYAML(into, from, projectDescriptor, semantics = {}) {
                 const relationship = semantics.relationships?.filter(r => r)
                     .find(relationship => {
                         const [existence, keyPath] = relationship.into
-                        if (!existenceMap.get(existence.ref)) return false
-                        const existingNode = _getYAMLProperty(existenceMap.get(existence.ref).node, keyPath)
+                        if (!existenceMap.get(existence)) return false
+                        const existingNode = _getYAMLProperty(existenceMap.get(existence).node, keyPath)
                         return targetNode === existingNode
                 })
                 if (!relationship) return
@@ -295,12 +293,12 @@ async function mergeYAML(into, from, projectDescriptor, semantics = {}) {
                 const intoKey = relationship.into[relationship.into.length - 1]
                 const [existence, existenceKeyPath] = relationship.insert
                 const missingPairs = [existence]
-                    .filter(({ref}) =>
-                        !targetJSON.some(item =>
-                            _getProperty(existenceMap.get(ref).json, existenceKeyPath) === item[intoKey]
+                    .filter(item =>
+                        !targetJSON.some(targetItem =>
+                            _getProperty(existenceMap.get(item).json, existenceKeyPath) === targetItem[intoKey]
                         )
                     )
-                    .map(({ref}) => existenceMap.get(ref).node.get(intoKey))
+                    .map(item => existenceMap.get(item).node.get(intoKey))
                 missingPairs.forEach(pair => {
                     targetNode.add({ [intoKey]: pair })
                 })

package/lib/init/util/mvnArchetypeUtil.js

@@ -2,10 +2,19 @@
 const { MAVEN_ARCHETYPE_VERSION, OPTION_JAVA_MVN,
     OPTION_JAVA_PACKAGE, OPTION_SAMPLES, REGEX_JAVA_PACKAGE, OPTION_HANA } = require('../constants');
 
+const { CliError } = require('../../client/helper/errors');
+
+
+const cp = require('child_process');
+const util = require('util');
+const execAsync = util.promisify(cp.exec);
+
+
 const DEFAULT_GROUP_ID = 'customer';
 
 const LOG = console
-const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) && console.debug
+const cds = require('../../cds')
+const DEBUG = cds.debug('cli')
 
 class MvnArchetypeUtil {
 
@@ -88,7 +97,7 @@ class MvnArchetypeUtil {
         return packageName.toLowerCase().replace(/-/g, '_').replace(/\.([0-9])/g, '._$1').replace(/^([0-9])/, '_$1').replace(/\.+/g, '.');
     }
 
-    getGenerateCmdArgs(projectName, options) {
+    async getGenerateCmdArgs(projectName, options) {
         const params = new Map();
 
         // set header
@@ -115,6 +124,29 @@ class MvnArchetypeUtil {
             this._scanMvnParams(options[OPTION_JAVA_MVN], params);
         }
 
+        // -DjdkVersion=[11|17]
+        if (!params.get('-DjdkVersion')) {
+            try {
+                const javaVersion = await execAsync('java -version');
+                const match = javaVersion?.stderr?.match(/version\s*"?(\d+\.\d+\.\d+)"?/);
+                if (match?.[1]) {
+                    const segments = match[1]?.split('.');
+                    const version = new Number(segments?.[0]);
+                    switch (true) {
+                        case (version < 11): throw new CliError(`Java version ${match[1]} is not supported. Use Java 11 or higher.`);
+                        case (version <= 16): params.set(`-DjdkVersion`, 11); break;
+                        case (version > 16): params.set(`-DjdkVersion`, 17); break;
+                        default:
+                    }
+                }
+            } catch (err) {
+                if (err instanceof CliError) {
+                    throw err;
+                }
+                DEBUG?.(err);
+            }
+        }
+
         if (options[OPTION_JAVA_PACKAGE]) {
             params.set(`-Dpackage`, options[OPTION_JAVA_PACKAGE]);
         }

package/lib/init/util/projectReader.js

@@ -1,7 +1,6 @@
-const path = require('path')
 const cds = require('../../cds')
+const { path, read, exists } = cds.utils
 const { BuildTaskFactory } = cds.build
-const { read, exists } = cds.utils
 const P_LANGUAGE_JAVA = 'java'
 const P_LANGUAGE_NODEJS = 'nodejs'
 const DEFAULT_P_LANGUAGE = P_LANGUAGE_NODEJS
@@ -16,31 +15,34 @@ const BUILD_TASK_MTX_SIDECAR = "mtx-sidecar"
 const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) && console.debug
 const LOG = console
 
-module.exports = class ProjectReader {
+module.exports = new class ProjectReader {
 
-    constructor(projectPath) {
-        this.projectPath = projectPath
+    constructor() {
+        this.readProject = this.readProject.bind(this)
     }
 
+    // REVISIT: There should be a better (and parallelizable) API provided by cds.env
     /**
      * Returns cds.env using 'production' profile by default as mta deployment is executed with having production profile set.
      */
-    async getEnv(profile = 'production') {
+    getEnv(profile = 'production') {
         const cdsEnvVar = process.env.CDS_ENV
         process.env.CDS_ENV = profile
         try {
-            return cds.env.for('cds', exists(this.projectPath) ? this.projectPath : this.cwd);
+            return cds.env.for('cds')
         } finally {
             cdsEnvVar ? process.env.CDS_ENV = cdsEnvVar : delete process.env.CDS_ENV
         }
     }
 
-    async read(options) {
-        const env = await this.getEnv();
+    async readProject(options) {
+        if (options?.cwd) cds.root = options.cwd
+
+        const env = this.getEnv()
         DEBUG && DEBUG({ env })
 
         const cap = await this._getCapDescriptor(env, options)
-        const ui = await this._getUiDescriptor(env)
+        const ui = this._getUiDescriptor(env)
         const projectDescriptor = { cap, ui }
         this._validateDbFolders(cap)
 
@@ -49,28 +51,27 @@ module.exports = class ProjectReader {
     }
 
     _validateDbFolders(cap) {
-        const { root, db: dbs, isJava } = cap
+        const { db: dbs, isJava } = cap
         if (isJava) {
-            for (const db of dbs) if (!exists(path.join(root, db.path, 'package.json'))) {
+            for (const db of dbs) if (!exists(path.join(db.path, 'package.json'))) {
                 LOG.error(`Missing 'package.json' in folder ${db.path} - 'cds add hana' adds configuration for SAP HANA`)
             }
         }
     }
 
     async _getCapDescriptor(env, options) {
-        const projectPath = this.projectPath
-        const _hasFacet = template => require(`../template/${template}`).hasFacet(env, projectPath, options)
+        const _hasFacet = template => require(`../template/${template}`).hasFacet(env, options)
         const cap = {
             for: options?.for,
             pLanguage: DEFAULT_P_LANGUAGE,
             srv: {},
             db: [],
             requires: [],
-            get root()           { return projectPath },
             get hasRequires()    { return this.requires.length > 0 },
             get needsSidecar()   { return (options?.add.has('hana') || this.db.length > 0) && (this.isJava || !this.isMultitenant) },
             get isNodejs()       { return this.pLanguage === P_LANGUAGE_NODEJS },
             get isJava()         { return this.pLanguage === P_LANGUAGE_JAVA },
+            get hasSidecar()     { return exists('mtx', 'sidecar') },
             get isMultitenant()  { return _hasFacet('multitenancy') },
             get isExtensible()   { return _hasFacet('extensibility') },
             get hasHana()        { return _hasFacet('hana') },
@@ -92,13 +93,15 @@ module.exports = class ProjectReader {
         const nullLogger = { debug: () => { }, log: () => { }, warn: () => { }, error: () => { }, write: () => { } }
 
         // no file path resolving as the directories might not exist - e.g. cds add will create the mtx/sidecar folder
-        const buildTasks = await new BuildTaskFactory(nullLogger, cds).getTasks({ root: this.projectPath, resolve: false, mta: false })
+        // REVISIT: Leaner API from cds.build
+        const buildTasks = await new BuildTaskFactory(nullLogger, cds).getTasks({ root: cds.root, resolve: false, mta: false })
 
         await Promise.all(buildTasks.map(async (task) => {
-            const srcPath = path.resolve(this.projectPath, task.src)
+            const srcPath = path.resolve(cds.root, task.src)
             const srcFolder = path.basename(srcPath)
             const relDestPath = path.join(env?.build?.target ?? "gen", task.dest || task.src)?.replace(/\\/g, '/')
 
+
             switch (task.for) {
                 case BUILD_TASK_HANA:
                     // check whether we have a hana service binding defined as a hana build task is returned by default for compatibility reasons if neither hana, nor sqlite has been defined
@@ -158,7 +161,7 @@ module.exports = class ProjectReader {
                 throw new Error("Projects using the classic CAP Java SDK are not supported")
             }
 
-            const descriptor = { archiveName: path.basename(this.projectPath) + "-exec.jar" }
+            const descriptor = { archiveName: path.basename(cds.root) + "-exec.jar" }
             const archiveName = pomJson?.project?.artifactId?.[0]
             const suffix = pomJson?.project?.packaging?.[0]
             if (archiveName) descriptor.archiveName = archiveName + '-exec.' + suffix
@@ -166,8 +169,8 @@ module.exports = class ProjectReader {
         }
     }
 
-    async _getUiDescriptor(env) {
-        const absoluteAppPath = path.join(this.projectPath, env.folders.app)
+    _getUiDescriptor(env) {
+        const absoluteAppPath = path.join(cds.root, env.folders.app)
         return {
             appPath: exists(absoluteAppPath) ? env.folders.app : null
         }
@@ -180,7 +183,7 @@ module.exports = class ProjectReader {
 
         // 1.1. java - use parent pom.xml
         if (cap.pLanguage === P_LANGUAGE_JAVA) {
-            const pomXmlPath = path.join(this.projectPath, 'pom.xml')
+            const pomXmlPath = path.join(cds.root, 'pom.xml')
             try {
                 if (exists(pomXmlPath)) {
                     const pomJson = await this._parseXml(pomXmlPath)
@@ -213,7 +216,7 @@ module.exports = class ProjectReader {
 
         // 1.2. use package.json
         if (!cap.appName) {
-            const packageJsonPath = path.join(this.projectPath, 'package.json')
+            const packageJsonPath = path.join(cds.root, 'package.json')
             if (exists(packageJsonPath)) {
                 try {
                     const { name, version, description } = await read(packageJsonPath)
@@ -233,7 +236,7 @@ module.exports = class ProjectReader {
         }
 
         // 2. use project name and static default values
-        cap.appName = cap.appName ?? path.basename(this.projectPath)
+        cap.appName = cap.appName ?? path.basename(cds.root)
         cap.appDescription = cap.appDescription ?? cap.appName + " application"
         cap.appId = cap.appId ?? cap.appName
         cap.appVersion = cap.appVersion ?? '1.0.0'
@@ -304,7 +307,7 @@ module.exports = class ProjectReader {
      */
     async _parseXml(pomXmlPath) {
         const xmljs = require('xml-js');
-        let xmljsParse = {};
+        const xmljsParse = {};
         try {
             const xml = await read(pomXmlPath, 'utf-8')
             xmljsParse.project = JSON.parse(await xmljs.xml2json(xml, {