@sap/cds-dk 7.8.1 → 7.9.1

package/lib/env/schemas/cds-rc.js

@@ -1,6 +1,6 @@
 module.exports = {
     title: "JSON schema for CDS-DK configuration",
-    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $schema: "https://json-schema.org/draft-07/schema",
     description: "Build overlay",
     $defs: {
         cdsRoot: {
@@ -8,22 +8,25 @@ module.exports = {
                 // declaration for schema node for cds plugins contributing cds configuration
                 schema: {
                     type: "object",
+                    default: {},
                     description: "Schema declaration for cds plugins contributing cds configuration",
                     additionalProperties: false,
                     properties: {
                         cds: {
                             type: "object",
+                            default: {},
                             description: "Containing json schema declarations for root level entries under cds node.",
                             patternProperties: {
                                 // new keyword must start with word character or opening brackets
                                 "^[\\[\\(\\w].*": {
-                                    $ref: "https://json-schema.org/draft/2020-12/schema"
+                                    $ref: "https://json-schema.org/draft-07/schema"
                                 }
                             }
                         },
 
                         buildTaskType: {
                             type: "object",
+                            default: {},
                             additionalProperties: false,
                             required: ["name"],
                             properties: {
@@ -41,6 +44,7 @@ module.exports = {
 
                         databaseType: {
                             type: "object",
+                            default: {},
                             additionalProperties: false,
                             required: ["name"],
                             properties: {
@@ -61,8 +65,16 @@ module.exports = {
                 // build specific schema
                 build: {
                     type: "object",
+                    default: {},
                     description: "Customize CDS build settings.",
                     additionalProperties: true,
+                    patternProperties: {
+                        '\\[.+\\]': {
+                            default: {},
+                            description: 'Generic build profile',
+                            $ref: '#/$defs/cdsRoot/properties/build'
+                        }
+                    },
                     properties: {
                         target: {
                             type: "string",
@@ -79,6 +91,13 @@ module.exports = {
                             items: {
                                 type: "object",
                                 additionalProperties: true,
+                                patternProperties: {
+                                    '\\[.+\\]': {
+                                        default: {},
+                                        description: 'Generic tasks profile',
+                                        $ref: '#/$defs/cdsRoot/properties/build/properties/tasks/items'
+                                    }
+                                },
                                 properties: {
                                     dest: {
                                         type: "string",
@@ -115,8 +134,16 @@ module.exports = {
                 // deploy specific schema
                 deploy: {
                     type: "object",
+                    default: {},
                     description: "Customize 'cds deploy' settings.",
                     additionalProperties: true,
+                    patternProperties: {
+                        '\\[.+\\]': {
+                            default: {},
+                            description: 'Generic deploy profile',
+                            $ref: '#/$defs/cdsRoot/properties/deploy'
+                        }
+                    },
                     properties: {
                         no_save: {
                             type: "boolean",

package/lib/import/odata/v4parser.js

@@ -99,7 +99,7 @@ function _initialize(parserContext) {
     parserContext.primarySchema = "";
     parserContext.schemaAliasToNamespace = {};
     parserContext.schemaToSchemaDataIndex = {};
-    parserContext.vocabAliasToNamespace = {};
+    parserContext.vocabNamespaceToAlias = {};
     parserContext.entityToBoundedActions = {};
     parserContext.entityToBoundedFunctions = {};
     parserContext.entityContainerAnnotations = {};
@@ -425,23 +425,62 @@ function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTarg
     }
 }
 
-function _resolveAnotationTerm(schemaDataAnnotation, parserContext) {
-    // Case 1: We have the Namespace and Alias for the vocabulary
-    for (const [alias, namespace] of Object.entries(parserContext.vocabAliasToNamespace)) {
-        if (schemaDataAnnotation.includes('@' + alias + '.')) {
-            schemaDataAnnotation = schemaDataAnnotation.split('@' + alias + '.').join('@' + known_vocabularies[namespace] + '.');
+function _validateAnnotationNamespace(annotationTerm, vocabNamespaceToAlias) {
+    let aliasOrNamespace = annotationTerm.substring(1, annotationTerm.lastIndexOf('.'));
+
+    for (let alias of Object.values(known_vocabularies)) {
+        if (alias === aliasOrNamespace) {
+            return;
+        }
+    }
+
+    for (let [namespace, alias] of Object.entries(vocabNamespaceToAlias)) {
+        if (alias === aliasOrNamespace || namespace === aliasOrNamespace) {
+            console.log(warn(annotationTerm + " AnnotationTerm belongs to an unknown namespace: " + namespace));
+            return;
+        }
+    }
+
+    console.log(warn(annotationTerm + ": Reference of this AnnotationTerm is not present in the edmx file."));
+}
+
+function _resolveAnnotationTerm(schemaDataAnnotation, parserContext) {
+
+    for (const [namespace, alias] of Object.entries(parserContext.vocabNamespaceToAlias)) {
+        if (known_vocabularies[namespace]) {
+            // Case 1: Namespace belongs to known vocabularies. Replacing the namespace/alias of the doc with standard alias
+            if (schemaDataAnnotation.includes('@' + alias + '.')) {
+                schemaDataAnnotation = schemaDataAnnotation.split('@' + alias + '.').join('@' + known_vocabularies[namespace] + '.');
+            }
+            if (schemaDataAnnotation.includes('@' + namespace + '.')) {
+                schemaDataAnnotation = schemaDataAnnotation.split('@' + namespace + '.').join('@' + known_vocabularies[namespace] + '.');
+            }
+        } else {
+            // Case 2: Namespace doesn't belong to known vocabularies. Replacing the namespace with alias(if provided) in the doc.
+            if (schemaDataAnnotation.includes('@' + namespace + '.') && alias) {
+                schemaDataAnnotation = schemaDataAnnotation.split('@' + namespace + '.').join('@' + alias + '.');
+            }
         }
     }
     /**
-     * Case 2: We only have the Namespace for the vocabulary
-     * Case 3: We don't have the edmx:Reference at all
+     * Case 3: Namespace doesn't have edmx:Reference. But it is present in known_vocabularies. 
+     *         Replacing it with standard alias.
      */
-    for (const [vocabulary, alias] of Object.entries(known_vocabularies)) {
-        if (schemaDataAnnotation.includes(vocabulary)) {
-            schemaDataAnnotation = schemaDataAnnotation.split(vocabulary).join(alias);
+    for (const [namespace, alias] of Object.entries(known_vocabularies)) {
+        if (schemaDataAnnotation.includes(namespace)) {
+            schemaDataAnnotation = schemaDataAnnotation.split(namespace).join(alias);
         }
     }
 
+    let index = 0;
+    while (schemaDataAnnotation.indexOf('@', index) != -1) {
+
+        let i = schemaDataAnnotation.indexOf('@', index);
+        let annotationTerm = schemaDataAnnotation.substring(i, schemaDataAnnotation.indexOf('"', i));
+        _validateAnnotationNamespace(annotationTerm, parserContext.vocabNamespaceToAlias);
+        index = i+1;
+    }
+
     return JSON.parse(schemaDataAnnotation);
 }
 
@@ -459,7 +498,7 @@ function _captureAnnotationWithinElement(sourceObject, targetObject, parserConte
 
     Object.keys(sourceObject).forEach(key => {
         if (key.startsWith('@')) {
-            element = _resolveAnotationTerm(JSON.stringify(key), parserContext);
+            element = _resolveAnnotationTerm(JSON.stringify(key), parserContext);
             _parseAnnotationTerms(element, sourceObject[key], targetObject, parserContext);
         }
     });
@@ -1309,7 +1348,7 @@ function _parseEntityContainer(csnDefs, entityContainerElements, parserContext)
     if (Object.keys(possibleAnnotations).length > 0) {
         let entityContainerAnnotations = {};
         let annotationTarget = parserContext.primarySchema + '.' + parserContext.entityContainerName;
-        possibleAnnotations = _resolveAnotationTerm(
+        possibleAnnotations = _resolveAnnotationTerm(
             JSON.stringify(possibleAnnotations), parserContext
         );
         /**
@@ -1447,16 +1486,28 @@ function _collectBoundedActionFunction(isAction, currNamespace, elementName, ele
     for (let i = 0; i < elementDataList.length; i++) {
         let dataObj = elementDataList[i];
         let boundedEntityName = dataObj.$Parameter[0].$Type;
+        let entityTypeNamespace = currNamespace;
         let [schemaName, entityName] = _extractSchemaNameAndElementName(boundedEntityName);
 
-        // binding parameter type should be within the current schema only
-        if (currNamespace !== schemaName && currNamespace !== parserContext.schemaAliasToNamespace[schemaName]) {
-            throw new Error(messages.INVALID_BOUNDED_PARAM_TYPE + ` Check the Element: ${elementName} of Schema: ${currNamespace} `);
+        // binding parameter type should be within the available namespaces in the scope of a document.
+        if (entityTypeNamespace !== schemaName && entityTypeNamespace !== parserContext.schemaAliasToNamespace[schemaName]) {
+            
+            // checking if the namespace is available in other schema of the document
+            if (parserContext.schemaToSchemaDataIndex.hasOwnProperty(schemaName)) {
+                entityTypeNamespace = schemaName;
+            }
+            // checking if the alias is present for the schema name and assigning the actual namespace
+            else if (parserContext.schemaAliasToNamespace[schemaName]) {
+                entityTypeNamespace = parserContext.schemaAliasToNamespace[schemaName];
+            } else {
+                throw new Error(messages.INVALID_BOUNDED_PARAM_TYPE + ` Check the Element: ${elementName} of Schema: ${currNamespace} `);
+            }
         }
-        if (!parserContext.entityTypes.includes(currNamespace + '.' + entityName)) {
+
+        if (!parserContext.entityTypes.includes(entityTypeNamespace + '.' + entityName)) {
             throw new Error(messages.UNRESOLVED_TYPE + boundedEntityName);
         }
-        boundedEntityName = currNamespace + '.' + entityName;
+        boundedEntityName = entityTypeNamespace + '.' + entityName;
 
         if (isAction) {
             if (!parserContext.entityToBoundedActions[boundedEntityName]?.[elementName]) {
@@ -1501,17 +1552,15 @@ function _collectBoundedActionFunction(isAction, currNamespace, elementName, ele
  * @param {Object} parserContext, contains parser level context informations
  */
 function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
+    // This array is used to store the parameter values which will be used later to call _collectBoundedActionFunction.
+    let boundActionFunctionDetails = [];
 
     _collectUnboundedActionFunction(schemaDataList, parserContext);
 
     // capture all the references
     if (edmxAsJson.$Reference) {
         Object.entries(edmxAsJson.$Reference).forEach(ref => {
-            if (ref[1].$Include[0].$Alias &&
-                known_vocabularies.hasOwnProperty(ref[1].$Include[0].$Namespace)
-            ) {
-                parserContext.vocabAliasToNamespace[ref[1].$Include[0].$Alias] = ref[1].$Include[0].$Namespace;
-            }
+            parserContext.vocabNamespaceToAlias[ref[1].$Include[0].$Namespace] = ref[1].$Include[0].$Alias;
         });
     }
 
@@ -1532,12 +1581,12 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
                 else if (elementData instanceof Array) {
                     let isAction = elementData[0].$Kind === 'Action' ? true : false;
                     if (elementData[0].$IsBound) {
-                        _collectBoundedActionFunction(isAction, currNamespace, elementName, elementData, parserContext);
+                        boundActionFunctionDetails.push([isAction, currNamespace, elementName, elementData]);
                     }
                 }
                 // annotations
                 else if (elementName === '$Annotations') {
-                    schemaData.$Annotations = _resolveAnotationTerm(JSON.stringify(schemaData.$Annotations), parserContext);
+                    schemaData.$Annotations = _resolveAnnotationTerm(JSON.stringify(schemaData.$Annotations), parserContext);
                     /**
                      * collect entity container annotations with the assumption that
                      * we only have a single entity container
@@ -1558,6 +1607,10 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
             }
         });
     }
+    // This will delay the execution of _collectBoundedActionFunction, as we need to collect all the entityTypes first.
+    boundActionFunctionDetails.forEach(paramValues => {
+        _collectBoundedActionFunction(...paramValues, parserContext);
+    });
 }
 
 function _preProcess(edmxAsJson, parserContext, importerContext) {

package/lib/init/constants.js

@@ -4,7 +4,8 @@ module.exports = {
     COMMAND_INIT: 'init',
     COMMAND_ADD: 'add',
 
-    MAVEN_ARCHETYPE_VERSION: '2.8.1',
+    JAVA_LTS_VERSIONS: [17, 21],
+    MAVEN_ARCHETYPE_VERSION: '2.9.0',
 
     OPTIONS: Object.freeze({
         JAVA: 'java',

package/lib/init/index.js

@@ -109,7 +109,11 @@ module.exports = class CDSGenerator {
         this._initialize(null);
         this._greetings();
 
-        if (!PROJECT_FILES.find(exists)) {
+        // `add completion` configures global shell completion and not project settings
+        // `add data` can live without project metadata
+        const nonProjectFacets = { completion:1, data:1 }
+        const needsProject = facets.some(facet => !nonProjectFacets[facet])
+        if (needsProject && !PROJECT_FILES.find(exists)) {
             throw `The current folder doesn't seem to contain a project. None of the following files found: ${PROJECT_FILES.join(', ')}.`
         }
 
@@ -165,7 +169,7 @@ module.exports = class CDSGenerator {
         if (cds.cli.options.for && typeof cds.cli.options.for !== 'string') {
             throw 'The --for argument must not be empty.'
         }
-        if (cds.cli.options.force) {
+        if (cds.cli.options.force && !cds.cli.options.dry) {
             console.log(`Using '--force' ... existing files will be overwritten`)
         }
     }
@@ -174,10 +178,14 @@ module.exports = class CDSGenerator {
         DEBUG?.(`Project path: ${cds.root}`);
 
         await this._validateOptions();
-        await this._fillTemplateList(facets);
 
-        for (const template of this.templateList) {
-            console.log(`Adding feature '${template.name}'...`);
+        const { command, options } = cds.cli
+        const plugins = command === COMMAND_INIT ? options.add : new Set(facets)
+        await this._fillTemplateList(plugins)
+
+        for (const [i, facet] of Object.entries(Array.from(plugins))) {
+            if (!cds.cli.options.dry) console.log(`Adding feature '${facet}'...`);
+            const template = this.templateList[i]
             await template.run();
             await template.combine();
             await template.combineSupported();
@@ -190,7 +198,7 @@ module.exports = class CDSGenerator {
                 message = message + ` Continue with '${term.bold('cd ' + relativeProjectPath)}'.`
             }
             console.log('\n' + message)
-        } else {
+        } else if (!cds.cli.options.dry) {
             console.log(`\nSuccessfully added features to your project.`)
         }
     }
@@ -216,11 +224,8 @@ module.exports = class CDSGenerator {
         }
     }
 
-    async _fillTemplateList(facets) {
+    async _fillTemplateList(plugins) {
         const templates = new Map
-        const { command, options } = cds.cli
-
-        const plugins = command === COMMAND_INIT ? options.add : new Set(facets)
 
         for (let plugin of plugins) {
             // Compat
@@ -230,13 +235,13 @@ module.exports = class CDSGenerator {
                 cds.cli.options.add.add('helm-unified-runtime')
             }
             if (plugin === 'sample-tiny') plugin = 'tiny-sample'
-            if (plugin in { 'kibana-logging':1, 'kibana':1 }) plugin = 'application-logging'
+            if (plugin in { 'kibana-logging': 1, 'kibana': 1 }) plugin = 'application-logging'
             if (plugin === 'postgresql') plugin = 'postgres'
 
             if (!templates.has(plugin)) {
                 const template = await this._createTemplate(plugin)
                 if (await template.canRun()) {
-                    DEBUG?.(`Adding feature '${template.name}'`)
+                    DEBUG?.(`Adding feature '${plugin}'`)
                     templates.set(plugin, template)
                     const dependencies = await template.requires()
                     dependencies?.forEach(d => plugins.add(d))
@@ -256,7 +261,7 @@ module.exports = class CDSGenerator {
             .map((entry) => entry[1])
 
         // check debug to avoid lengthy computation when not in debug mode
-        DEBUG?.(`Features: ${this.templateList.map(({name}) => name).join(', ')}`);
+        DEBUG?.(`Features: ${this.templateList.map(({ name }) => name).join(', ')}`);
     }
 
     // CAP Generator API

package/lib/init/merge.js

@@ -182,6 +182,7 @@ async function _mergeYAML(into, from, project, semantics = {}) {
         if (additions) _addToMap(additions)
         if (deletions) _addToMap(deletions.map(deletion => deletion.item))
         if (relationships) _addToMap(relationships?.map(({into: [entry]}) => entry).filter(e => e))
+        if (overwrites) _addToMap(overwrites.map(overwrite => overwrite.item[0]))
     }
 
     function _traverseYAMLNode(node, index, actions, templateNode) {

package/lib/init/mvn.js

@@ -72,40 +72,6 @@ class MvnArchetypeUtil {
         return this._finalize(params);
     }
 
-    getAddSamplesCmdArgs() {
-        const params = new Map();
-
-        params.set(`com.sap.cds:cds-maven-plugin:${MAVEN_ARCHETYPE_VERSION}:addSample`);
-
-        const { options } = cds.cli
-        if (options[JAVA_MVN]) {
-            this._scanMvnParams(options[JAVA_MVN], params);
-        }
-
-        if (options.force) {
-            params.set(`-Doverwrite`, true);
-        }
-
-        return this._finalize(params);
-    }
-
-    getAddTestsCmdArgs() {
-        const params = new Map();
-
-        params.set(`com.sap.cds:cds-maven-plugin:${MAVEN_ARCHETYPE_VERSION}:addIntegrationTest`);
-
-        const { options } = cds.cli
-        if (options[JAVA_MVN]) {
-            this._scanMvnParams(options[JAVA_MVN], params);
-        }
-
-        if (options.force) {
-            params.set(`-Doverwrite`, true);
-        }
-
-        return this._finalize(params);
-    }
-
     getAddHanaCmdArgs() {
         const params = new Map();
 
@@ -155,19 +121,14 @@ class MvnArchetypeUtil {
             } catch (err) {
                 DEBUG?.(err);
             }
-            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 < 17):
-                        if (process.env.WS_BASE_URL) {
-                            throw `Java version ${match[1]} is not supported. Use Java 17 or higher. You can use command 'Java: Set Default JDK' to switch to Java 17.`
-                        }
-                        throw `Java version ${match[1]} is not supported. Use Java 17 or higher.`
-                    case (version < 20): params.set(`-DjdkVersion`, 17); break;
-                    case (version >= 20): params.set(`-DjdkVersion`, 20); break;
-                    default:
+            const [,version] = javaVersion?.stderr?.match(/version\s*"?(\d+\.\d+\.\d+)"?/) ?? [];
+            if (version) {
+                const [major] = version.split('.').map(Number);
+                if (major < 17) {
+                    if (process.env.WS_BASE_URL) {
+                        throw `Java version ${version} is not supported. Use Java 17 or higher. You can use command 'Java: Set Default JDK' to switch to Java 17.`
+                    }
+                    throw `Java version ${version} is not supported. Use Java 17 or higher.`
                 }
             }
         }

package/lib/init/plugin.js

@@ -6,10 +6,6 @@ const { env4 } = require('./projectReader')
 
 module.exports = class Plugin {
 
-    constructor() {
-        this.name = this.constructor.name.replace(/template/i, '').replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase()
-    }
-
     /**
      * Provides command-line options for the plugin.
      * @returns {Array.<{option: string, flag: string, shortcut?: string, help: string}>}

package/lib/init/projectReader.js

@@ -2,7 +2,7 @@ const cds = require('../cds')
 const { join, resolve, basename } = require('path')
 const { fs, exists, isdir, path } = cds.utils
 const { parseXml } = require('./xml')
-const { REGEX_JAVA_VERSION } = require('./constants')
+const { REGEX_JAVA_VERSION, JAVA_LTS_VERSIONS } = require('./constants')
 const DEBUG = cds.debug('cli')
 
 module.exports = new class ProjectReader {
@@ -15,18 +15,24 @@ module.exports = new class ProjectReader {
         this.appName = this.appId = basename(cds.root)
         this.appDescription = 'A simple CAP project.'
 
-        // 2. Use either pom.xml or package.json
-        if (exists('pom.xml')) {
-            const { artifactId = [], description = [], version = [], properties = [] } = parseXml(resolve(cds.root, 'pom.xml')) ?? {}
-            const v = version[0] === '${revision}' ? properties[0]?.revision[0] : version[0]
+        const isJava = exists('pom.xml') || cds.cli.options?.add?.has('java')
+        if (isJava) {
+            let artifactId, description, version, properties
+            try {
+                ({ artifactId, description, version, properties } = parseXml(resolve(cds.root, 'pom.xml')) ?? {})
+            } catch (e) {
+                if (e.code !== 'ENOENT') throw e
+            }
+            const v = version?.[0] === '${revision}' ? properties?.[0]?.revision[0] : version?.[0] ?? '1.0.0-SNAPSHOT'
             if (v && REGEX_JAVA_VERSION.test(v)) this.appVersion = v
-            if (artifactId[0])  this.appName = this.appId = artifactId[0].split(/-parent/)[0]
-            if (description[0]) this.appDescription = description[0]
+            this.jdkVersion = properties?.[0]?.['jdk.version']?.[0]?._text?.[0] ?? JAVA_LTS_VERSIONS[JAVA_LTS_VERSIONS.length - 1]
+            if (artifactId?.[0])  this.appName = this.appId = artifactId?.[0]?.split(/-parent/)[0]
+            if (description?.[0]) this.appDescription = description[0]
         }
         else if (exists('package.json')) {
             const { name, version, description } = JSON.parse(fs.readFileSync(join(cds.root, 'package.json')))
-            this.appVersion = version
-            const segments = name.trim().replace(/@/g, '').split('/').map(encodeURIComponent)
+            this.appVersion = version ?? this.appVersion
+            const segments = (name ?? this.appName).trim().replace(/@/g, '').split('/').map(encodeURIComponent)
             this.appName = segments[segments.length - 1]
             this.appId = segments.join('.')
             this.appDescription = description ?? this.appDescription
@@ -90,7 +96,7 @@ module.exports = new class ProjectReader {
      */
     readProject() {
         const env = this.env4('production')
-        const { appVersion, appName, appId, appDescription } = this
+        const { appVersion, appName, appId, appDescription, jdkVersion } = this
         DEBUG?.({ env })
 
         const _inProd = plugin => require(`./template/${plugin}`).hasInProduction(env)
@@ -121,6 +127,7 @@ module.exports = new class ProjectReader {
             ),
             appPath: () => env.folders.app,
             appVersion: () => appVersion,
+            jdkVersion: () => jdkVersion,
             approuterPath: () => join(env.folders.app, 'router'),
             appName: () => appName,
             cleanedAppName: () => appName.replaceAll('_', '-'),

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

@@ -1,20 +1,14 @@
 ---
-{{#hasXsuaa}}
-xsuaa:
-  parameters:
-    oauth2-configuration:
-      redirect-uris:
-      - https://*.<your-cluster-domain>/**
-{{/hasXsuaa}}
 approuter:
-{{#hasXsuaa}}
-  bindings:
-    auth:
-      serviceInstanceName: xsuaa
-{{/hasXsuaa}}
   image:
     repository: <your-container-registry>/{{appName}}-approuter
     tag: latest
+{{#hasMultitenancy}}
+{{=<% %>=}}
+  env:
+    TENANT_HOST_PATTERN: ^(.*)-{{ .Release.Name }}-approuter-{{ .Release.Namespace }}.{{ .Values.global.domain }} # change if expose.host is set
+<%={{ }}=%>
+{{/hasMultitenancy}}
   resources:
     limits:
       ephemeral-storage: 1G

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

@@ -63,13 +63,7 @@ module.exports = class ApprouterTemplate extends require('../../plugin') {
                 }
             }]}}).into('chart/values.yaml', { with: project })
 
-            const fileName = hasMultitenancy ? 'approuter-mtxs-configmap.yaml' : 'approuter-configmap.yaml'
-            await copy(join(__dirname, 'files', fileName)).to('chart', 'templates', 'approuter-configmap.yaml')
-
-            if (hasMultitenancy) {
-                const mtxsConfigMapFileName = isNodejs ? 'mtxs-configmap-nodejs.yaml' : 'mtxs-configmap-java.yaml'
-                await copy(join(__dirname, 'files', mtxsConfigMapFileName)).to('chart', 'templates', 'mtxs-configmap.yaml')
-            }
+            await copy(join(__dirname, 'files/approuter-configmap.yaml')).to('chart', 'templates', 'approuter-configmap.yaml')
         }
 
         const xsAppPath = join(approuterPath, 'xs-app.json')