@sap/cds-dk 7.4.1 → 7.5.0

package/lib/init/{util/merge.js → merge.js}

@@ -1,20 +1,21 @@
 const YAML = require('@sap/cds-foss').yaml
-const { copy, read, write, exists } = require('../../cds').utils
-const { readYAML, writeYAML, readJSON } = require('../../util/fs')
+const cds = require('../cds')
+const { copy, read, write, exists } = cds.utils
+const { readYAML, writeYAML, readJSON } = require('../util/fs')
 const { EOL } = require('node:os')
-const { detectIndent } = require('../util/indent')
+const { detectIndent } = require('./indent')
 
 function _isObject(item) {
   return item && typeof item === 'object' && !Array.isArray(item)
 }
 
-function _deepMerge(target, source) {
+function _mergeObject(target, source) {
   const unique = array => [...new Set(array.map(JSON.stringify))].map(JSON.parse)
   if (_isObject(target) && _isObject(source)) {
       for (const key in source) {
           if (_isObject(source[key])) {
               if (!target[key]) Object.assign(target, { [key]: source[key] })
-              else _deepMerge(target[key], source[key])
+              else _mergeObject(target[key], source[key])
           } else if (Array.isArray(source[key]) && Array.isArray(target[key])) {
               target[key] = unique([...source[key], ...target[key]])
           } else {
@@ -56,9 +57,7 @@ async function mergeGitignore (into, from) {
 /**
  * @typedef {Object} MatchedNode
  * @property {string | MatchedNode} in - key path or matched node to start search from
- * @property {Object[]} where - list of constraints
- * @property {string} where[].property - property key path
- * @property {string} where[].isEqualTo - comparison string
+ * @property {Object} where - list of constraints
  */
 
 /**
@@ -97,7 +96,7 @@ async function mergeGitignore (into, from) {
  * @param {MergingSemantics} [semantics] - merging algorithm semantics
  * @returns {Promise<JSON>} - merged JSON
  */
-async function mergeJSON(into, from, project, semantics) {
+async function _mergeJSON(into, from, project, semantics) {
     const source = typeof from === 'string' ? await readJSON(from, project) : from
 
     let result
@@ -107,11 +106,11 @@ async function mergeJSON(into, from, project, semantics) {
         const target = await read(into)
         const targetYAML = YAML.parseDocument(YAML.stringify(target))
         const sourceYAML = YAML.parseDocument(YAML.stringify(source))
-        const resultYAML = await mergeYAML(targetYAML, sourceYAML, project, semantics)
+        const resultYAML = await _mergeYAML(targetYAML, sourceYAML, project, semantics)
         result = YAML.parse(YAML.stringify(resultYAML))
     } else {
         const target = typeof into === 'string' ? await read(into, 'json') : into
-        result = _deepMerge(target, source)
+        result = _mergeObject(target, source)
     }
     // we need to stringify result on site to be able to apply the appropriate indentation.
     // cds-utils.write is currently hardcoded to use spaces for indentation.
@@ -130,7 +129,7 @@ async function mergeJSON(into, from, project, semantics) {
  * @returns {Promise<YAML.Document>} - merged YAML
  * @throws {Error} Throws an error if empty target YAML is passed in
  */
-async function mergeYAML(into, from, project, semantics = {}) {
+async function _mergeYAML(into, from, project, semantics = {}) {
     const target = typeof into === 'string' ? await readYAML(into) : into instanceof YAML.Document ? into : new YAML.Document(into)
     const source = typeof from === 'string' ? await readYAML(from, project) : from instanceof YAML.Document ? from : new YAML.Document(from)
 
@@ -166,16 +165,14 @@ async function mergeYAML(into, from, project, semantics = {}) {
 
     const _validateWhere = (node, dict, index) => {
         const _addToMap = entries => entries?.filter(entry => {
-                let where = entry.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)?.node
+                if (typeof entry.in === 'string') return true // just a key path on the document root
+                const neededParent = dict.get(entry.in[0])?.node
                 return collectionStack.includes(neededParent) // lookbehind in parent collection stack
                 // REVISIT: Only look behind until sequence is reached?
         }).forEach(item => {
             const json = JSON.parse(String(node))
-            const whereFulfilled = item.where.every(constraint =>
-                constraint.isEqualTo === _getProperty(json, constraint.property)
+            const whereFulfilled = Object.entries(item.where).every(([key, value]) =>
+                _getProperty(json, key) === value
             )
             if (whereFulfilled) {
                 const [collection] = collectionStack
@@ -415,11 +412,26 @@ async function removeFromYAMLArray(name, keyPath, aliasToRemove) {
     await writeYAML(name, yaml)
 }
 
+const path = require('path')
+const merge = (...src) => {
+    return { into: (dst, { with: withProject, project, ...semantics } = {}) => {
+        if (Object.keys(semantics).length === 0) semantics = undefined
+        project ??= withProject // to allow { with: project } for a more fluent API
+        const isYAML = typeof dst === 'string' && ['.yaml', '.yml', '.yaml.hbs', '.yml.hbs'].some(ext => dst.endsWith(ext))
+        const _merge = isYAML ? _mergeYAML : _mergeJSON
+        const target = typeof dst === 'string' ? path.resolve(cds.root, dst) : dst
+        if (typeof src[src.length-1] === 'string') {
+            return _merge(target, path.join(...src), project, semantics)
+        } else {
+            return _merge(target, ...src, project, semantics)
+        }
+    }}
+}
+
 module.exports = {
+  merge,
   sort,
   mergeGitignore,
-  mergeJSON,
-  mergeYAML,
   removeFromYAML,
   removeFromYAMLArray
 }

package/lib/init/{util/mvn.js → mvn.js}

@@ -1,16 +1,16 @@
 
-const { URLS, MAVEN_ARCHETYPE_VERSION, OPTIONS: { JAVA_MVN, JAVA_PACKAGE, SAMPLES, HANA }, REGEX_JAVA_PACKAGE } = require('../constants');
+const { URLS, MAVEN_ARCHETYPE_VERSION, OPTIONS: { JAVA_MVN, JAVA_PACKAGE, SAMPLES, HANA }, REGEX_JAVA_PACKAGE } = require('./constants');
 
 const cp = require('child_process');
 const util = require('util');
 const execAsync = util.promisify(cp.exec);
-const term = require('../../util/term');
-const cmd = require('../../util/command');
+const term = require('../util/term');
+const cmd = require('../util/command');
 
 const DEFAULT_GROUP_ID = 'customer';
 
 const LOG = console
-const cds = require('../../cds')
+const cds = require('../cds')
 const DEBUG = cds.debug('cli')
 
 class MvnArchetypeUtil {
@@ -58,7 +58,7 @@ class MvnArchetypeUtil {
         params.set(`com.sap.cds:cds-maven-plugin:${MAVEN_ARCHETYPE_VERSION}:add`);
         params.set(`-Dfeature`, feature)
         const profile = cds.cli.options.for
-        params.set(`-Dprofile`, profile === 'production' ? 'cloud' : profile)
+        params.set(`-Dprofile`, profile === 'production' ? 'cloud' : profile ?? 'default')
 
         const { options } = cds.cli
         if (options[JAVA_MVN]) {

package/lib/init/plugin.js

@@ -0,0 +1,85 @@
+const { join } = require('path')
+const cds = require('../cds')
+const { readdir } = cds.utils
+const DEBUG = cds.debug('add')
+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()
+    }
+
+    /**
+     * Gets the required templates.
+     * @returns {string[]} An array of strings representing required plugins.
+     *                     Returns an empty array by default.
+     *                     In general, avoid such dependencies if possible.
+     */
+    requires() { return [] }
+
+    /**
+     * Determines whether a plugin can be run.
+     * @returns {Promise<boolean>} A promise that resolves to `true` if the template can be run.
+     */
+    async canRun() { return true }
+
+    /**
+     * Determines if the plugin has already been added to the project.
+     * @param {import('@sap/cds').env} env - The env for the 'production' profile.
+     * @returns {boolean} - Returns `true` if the template has been added, otherwise `false`.
+     */
+    static hasInProduction(env) { // eslint-disable-line no-unused-vars
+        return false
+    }
+
+    /**
+     * Runs the plugin.
+     */
+    async run() { }
+
+    /**
+     * Runs the combine operations for interoperability with other plugins.
+     */
+    async combine() { }
+
+
+
+
+
+    /* ––––––––––––
+       Yeoman Generator
+       –––––––––––– */
+
+    /**
+     * Runs the finalize operations.
+     */
+    async finalize() { } // REVISIT: Required for yo-generator, check if needed any more?
+
+    /* ––––––––––––
+       Private APIs
+       –––––––––––– */
+
+    async combineSupported() {
+        DEBUG && console.log()
+        DEBUG && console.log('Plugins active for production:')
+        const fromDk = await readdir(join(__dirname, './template'))
+        const { registered } = require('./add')
+        const processPlugins = async (plugins) => {
+            for (const plugin of plugins) {
+                const Plugin = registered.get(plugin) ?? require('./template/' + plugin)
+                const template = new Plugin()
+                const inProduction = Plugin.hasInProduction(env4('production'))
+                DEBUG && console.log(inProduction ? '✅' : '❌', plugin)
+                if (inProduction) await template.combine()
+            }
+        }
+
+        if (DEBUG) console.log(`\n   ${fromDk.length} from @sap/cds-dk:`)
+        await processPlugins(fromDk)
+        if (DEBUG) console.log(`\n   ${registered.size} from plugins:`)
+        await processPlugins(registered.keys())
+
+        DEBUG && console.log()
+    }
+}

package/lib/init/projectReader.js

@@ -0,0 +1,145 @@
+const cds = require('../cds')
+const { join, resolve, basename } = require('path')
+const { fs, exists, isdir } = cds.utils
+const { parseXml } = require('./xml')
+const { REGEX_JAVA_VERSION } = require('./constants')
+const DEBUG = cds.debug('cli')
+
+module.exports = new class ProjectReader {
+
+    constructor() {
+        this.readProject = this.readProject.bind(this)
+
+        // 1. Use project name and static default values
+        this.appVersion = cds.cli.options.add?.has('java') ? '1.0.0-SNAPSHOT' : '1.0.0'
+        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]
+            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]
+        }
+        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.appName = segments[segments.length - 1]
+            this.appId = segments.join('.')
+            this.appDescription = description ?? this.appDescription
+        }
+    }
+
+    // REVISIT: There should an API provided by cds.env
+    /**
+     * Returns cds.env using 'production' profile by default as mta deployment is executed with having production profile set.
+     */
+    env4(profile = 'production') {
+        const cdsEnv = process.env.CDS_ENV
+        process.env.CDS_ENV = profile
+        try {
+            return cds.env.for('cds')
+        } finally {
+            cdsEnv ? process.env.CDS_ENV = cdsEnv : delete process.env.CDS_ENV
+        }
+    }
+
+    /**
+     * @typedef {Object} ProjectConfig
+     * @property {string} appVersion The version of the application.
+     * @property {string} appName The name of the application.
+     * @property {string} appId The ID of the application.
+     * @property {string} appDescription The description of the application.
+     * @property {string} language The programming language of the project.
+     * @property {string} srvPath The path to the server module.
+     * @property {string} archiveName The name of the archive.
+     * @property {Object} db Database configuration.
+     * @property {string} configFile The name of the configuration file. This is typically the `package.json` for Node.js and `.cdsrc.json` for Java.
+     * @property {string} appPath The path to the app folder.
+     * @property {boolean} hasUIEmbedded Indicates if the project uses an embedded UI.
+     * @property {boolean} hasUIModule Indicates if the project is using a modular UI.
+     * @property {boolean} hasUI Indicates if the project has a UI.
+     * @property {boolean} isJava Indicates if the project is using Java.
+     * @property {boolean} isNodejs Indicates if the project is using Node.js.
+     * @property {boolean} hasHelmUnifiedRuntime Indicates if the project uses Unified Runtime Helm deployment.
+     * @property {boolean} hasHelm Indicates if the project uses CAP Helm deployment.
+     * @property {boolean} hasMta Indicates if the project uses MTA deployment.
+     * @property {boolean} hasConnectivity Indicates if the project uses connectivity.
+     * @property {boolean} hasMultitenancy Indicates if the project is multitenant.
+     * @property {boolean} hasToggles Indicates if the project uses feature toggles.
+     * @property {boolean} hasExtensibility Indicates if the project is extensible.
+     * @property {boolean} hasXsuaa Indicates if the project uses XSUAA.
+     * @property {boolean} hasHana Indicates if the project uses HANA.
+     * @property {boolean} hasPostgres Indicates if the project uses PostgreSQL.
+     * @property {boolean} hasEnterpriseMessaging Indicates if the project uses SAP BTP Event Mesh.
+     * @property {boolean} hasApprouter Indicates if the project uses the SAP Application Router.
+     * @property {boolean} hasHtml5Repo Indicates if the project uses the SAP BTP HTML5 Application Repository.
+     * @property {boolean} hasDestination Indicates if the project uses the SAP BTP Destination service.
+     *
+     */
+
+    /**
+     * Reads the project configuration and constructs a project object.
+     * This function dynamically resolves project properties and returns an object with these properties.
+     *
+     * @returns {ProjectConfig} An object representing the project configuration.
+     */
+    readProject() {
+        const env = this.env4('production')
+        const { appVersion, appName, appId, appDescription } = this
+        DEBUG?.({ env })
+
+        const _inProd = plugin => require(`./template/${plugin}`).hasInProduction(env)
+        const reserved = {
+            has: x => _inProd(x),
+            shortcut: () => true,
+            profile: () => cds.cli.options?.for,
+            language: () => exists('pom.xml') ? 'java' : 'nodejs',
+            isJava: () => exists('pom.xml') || cds.cli.options?.add?.has('java'),
+            isNodejs: () => !exists('pom.xml') && !cds.cli.options?.add?.has('java'),
+            srvPath: () => join(env.build.target, env.folders.srv.replace(/\/$/, '')).replace(/\\/g, '/'),
+            archiveName: () => {
+                const pom = parseXml(resolve(cds.root, env.folders.srv, 'pom.xml'))
+                return (pom?.artifactId?.[0] ?? basename(cds.root)) + '-exec.' + pom?.packaging?.[0]
+            },
+            db: () => {
+                const folder = env.folders.db
+                const name = folder.replace(/\/$/, '')
+                const path = join(env.build.target, name).replace(/\\/g, '/')
+                return { folder, name, path }
+            },
+            configFile: () => exists('pom.xml') ? '.cdsrc.json' : 'package.json',
+            appPath: () => env.folders.app,
+            appVersion: () => appVersion,
+            appName: () => appName,
+            cleanedAppName: () => appName.replaceAll('_', '-'),
+            appId: () => appId,
+            appDescription: () => appDescription,
+            hasUIEmbedded: () => exists(join(env.folders.app, 'xs-app.json')),
+            hasUIModule: () => !this.hasUIEmbedded && isdir(env.folders.app) && fs.readdirSync(resolve(cds.root, env.folders.app)).length > 0,
+            hasUI: () => this.hasUIEmbedded || this.hasUIModule
+        }
+
+        const project = (() => {
+            const defined = {}
+            return new Proxy({}, {
+                get(_, p) { return _get(p) ?? defined[p] },
+                set(_, p, value) { defined[p] = value; return true },
+                has(_, p) { return _get(p) ?? p in defined }
+            })
+        })()
+
+        const _get = property => { const p = property
+            if (p in reserved) return reserved[p]()
+            for (const prefix of ['has', 'is']) if (p.startsWith(prefix) && p.length > prefix.length) {
+                return _inProd(p.slice(prefix.length).replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase())
+            }
+        }
+
+        DEBUG?.({ project })
+        return project
+    }
+}

package/lib/init/registries/mta.js

@@ -0,0 +1,151 @@
+// Registry of sequence matchers in mta.yaml files
+const cds = require('../../cds')
+
+const srvNode4 = path => ({ in: 'modules', where: { type: 'nodejs', path } })
+const srvJava4 = path => ({ in: 'modules', where: { type: 'java', path } })
+const srv4 = cds.env['project-nature'] === 'java' || cds.cli.options?.add?.has('java') ? srvJava4 : srvNode4
+
+const approuter = { in: 'modules', where: { type: 'approuter.nodejs' } }
+
+const xsuaa = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'xsuaa' }
+}
+
+const destination = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'destination' }
+}
+
+const connectivity = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'connectivity' }
+}
+
+const redis = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'redis-cache' }
+}
+
+const enterpriseMessaging = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'enterprise-messaging' }
+}
+
+const applicationLogging = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'application-logs' }
+}
+
+const hdbDeployer = {
+    in: 'modules',
+    where: { type: 'hdb' }
+}
+
+const hdiContainer = {
+    in: 'resources',
+    where: { type: 'com.sap.xs.hdi-container' }
+}
+
+const notificationTypesDeployer = {
+    in: 'modules',
+    where: { type: 'nodejs', name: 'notification-content-deployment' }
+}
+
+const serviceManager = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'service-manager', 'parameters.service-plan': 'container' }
+}
+
+const postgres = {
+    in: 'resources',
+    where: { 'parameters.service': 'postgresql-db' }
+}
+
+const postgresDeployer = {
+    in: 'modules',
+    where: { type: 'nodejs', path: 'gen/pg' }
+}
+
+const saasRegistry = {
+    in: 'resources',
+    where: { type: 'org.cloudfoundry.managed-service', 'parameters.service': 'saas-registry' }
+}
+
+const srvApi4 = srv => ({
+    in: [srv, 'provides'],
+    where: { name: 'srv-api', 'properties.srv-url': '${default-url}' }
+})
+
+const mtxSidecar4 = path => ({
+    in: 'modules',
+    where: { type: 'nodejs', path }
+})
+
+const providedMtxApiSidecar4 = mtxSidecar => ({
+    in: [mtxSidecar, 'provides'],
+    where: { name: 'mtx-api', 'properties.mtx-url': '${default-url}' }
+})
+
+const requiredMtxApi = {
+    in: [approuter, 'requires'],
+    where: { 'properties.name': 'mtx-api', 'properties.url': '~{mtx-url}' }
+}
+
+const providedAppApi = {
+    in: [approuter, 'provides'],
+    where: { name: 'app-api', 'properties.app-protocol': '${protocol}', 'properties.app-uri': '${default-uri}' }
+}
+
+const requiredAppApi4 = module => ({
+    in: [module, 'requires'],
+    where: { name: 'app-api', 'properties.SUBSCRIPTION_URL': '~{app-protocol}://\\${tenant_subdomain}-~{app-uri}' }
+})
+
+const requiredMtxSidecarApi4 = srv => ({
+    in: [srv, 'requires'],
+    where: { 'properties.CDS_MULTITENANCY_SIDECAR_URL': '~{mtx-url}' }
+})
+
+const providedJavaApprouterApi4 = srv => ({
+    in: [srv, 'requires'],
+    where: { 'properties.CDS_MULTITENANCY_APPUI_URL': '~{url}' }
+})
+
+const providedJavaApprouterApi = {
+    in: [approuter, 'requires'],
+    where: { 'properties.url': '${default-url}' }
+}
+
+const approuterExtensibility = {
+    in: 'routes',
+    where: { source: '^/-/cds/.*', destination: 'mtx-api', authenticationType: 'none' }
+}
+
+module.exports = {
+    srv4,
+    approuter,
+    xsuaa,
+    destination,
+    connectivity,
+    enterpriseMessaging,
+    hdbDeployer,
+    hdiContainer,
+    notificationTypesDeployer,
+    serviceManager,
+    postgres,
+    postgresDeployer,
+    saasRegistry,
+    redis,
+    srvApi4,
+    mtxSidecar4,
+    providedMtxApiSidecar4,
+    requiredMtxApi,
+    requiredMtxSidecarApi4,
+    providedAppApi,
+    requiredAppApi4,
+    providedJavaApprouterApi4,
+    providedJavaApprouterApi,
+    applicationLogging,
+    approuterExtensibility
+}

package/lib/init/template/{kibana → application-logging}/files/mta.yaml.hbs

@@ -6,13 +6,13 @@ modules:
     requires:
       - name: {{appName}}-logging
 
-{{#isMultitenant}}
+{{#hasMultitenancy}}
   - name: {{appName}}-mtx
     type: nodejs
     path: {{#isNodejs}}gen/{{/isNodejs}}mtx/sidecar
     requires:
       - name: {{appName}}-logging
-{{/isMultitenant}}
+{{/hasMultitenancy}}
 
 {{#hasApprouter}}
   - name: {{appName}}
@@ -26,4 +26,4 @@ resources:
     type: org.cloudfoundry.managed-service
     parameters:
       service: application-logs
-      service-plan: lite
+      service-plan: standard

package/lib/init/template/application-logging/index.js

@@ -0,0 +1,49 @@
+const { readProject } = require('../../projectReader')
+const { merge } = require('../../merge')
+const { srv4, mtxSidecar4, applicationLogging, approuter } = require('../../registries/mta')
+
+module.exports = class ApplicationLoggingTemplate extends require('../../plugin') {
+
+    static hasInProduction(env) {
+        return !!env.features.kibana_formatter
+    }
+
+    async canRun() {
+        const { hasMta, hasHelm, hasHelmUnifiedRuntime, isJava } = readProject()
+        if ((hasHelmUnifiedRuntime || hasHelm) && !hasMta) throw `'cds add application-logging' is not available for Kyma yet`
+        if (isJava) throw `'cds add application-logging' is not available for Java yet`
+        return true
+    }
+
+    async combine() {
+        const project = readProject()
+        const { hasMta, hasApprouter, isJava, hasMultitenancy, srvPath } = project
+
+        if (hasMta) {
+            const srv = srv4(srvPath)
+            const additions = [srv, applicationLogging]
+            const relationships = [{
+                insert: [applicationLogging, 'name'],
+                into: [srv, 'requires', 'name']
+            }]
+            if (hasMultitenancy) {
+                const mtxSidecar = mtxSidecar4(isJava ? 'mtx/sidecar' : 'gen/mtx/sidecar')
+                additions.push(mtxSidecar)
+                relationships.push({
+                    insert: [applicationLogging, 'name'],
+                    into: [mtxSidecar, 'requires', 'name']
+                })
+            }
+            if (hasApprouter) {
+                additions.push(approuter)
+                relationships.push({
+                    insert: [applicationLogging, 'name'],
+                    into: [approuter, 'requires', 'name']
+                })
+            }
+            await merge(__dirname, 'files/mta.yaml.hbs').into('mta.yaml', {
+                with: project, additions, relationships
+            })
+        }
+    }
+}

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

@@ -4,10 +4,10 @@ modules:
     type: {{language}}
     path: {{& srvPath}}
     {{#isJava}}
-    {{#isMultitenant}}
+    {{#hasMultitenancy}}
     properties:
       CDS_MULTITENANCY_APPUI_TENANTSEPARATOR: "-"
-    {{/isMultitenant}}
+    {{/hasMultitenancy}}
     {{/isJava}}
     requires:
       - name: {{appName}}-auth
@@ -24,10 +24,10 @@ modules:
       keep-existing-routes: true
       disk-quota: 256M
       memory: 256M
-    {{#isMultitenant}}
+    {{#hasMultitenancy}}
     properties:
       TENANT_HOST_PATTERN: "^(.*)-${default-uri}"
-    {{/isMultitenant}}
+    {{/hasMultitenancy}}
     requires:
       - name: srv-api
         group: destinations
@@ -35,14 +35,14 @@ modules:
           name: srv-api # must be used in xs-app.json as well
           url: ~{srv-url}
           forwardAuthToken: true
-      {{#isMultitenant}}
+      {{#hasMultitenancy}}
       - name: mtx-api
         group: destinations
         properties:
           name: mtx-api # must be used in xs-app.json as well
           url: ~{mtx-url}
-      {{/isMultitenant}}
-    {{#isMultitenant}}
+      {{/hasMultitenancy}}
+    {{#hasMultitenancy}}
     {{#isNodejs}}
     provides:
       - name: app-api
@@ -50,7 +50,7 @@ modules:
           app-protocol: ${protocol}
           app-uri: ${default-uri}
     {{/isNodejs}}
-    {{/isMultitenant}}
+    {{/hasMultitenancy}}
     {{#isJava}}
     provides:
       - name: app-api
@@ -58,7 +58,7 @@ modules:
           url: ${default-url}
     {{/isJava}}
 
-  {{#isMultitenant}}
+  {{#hasMultitenancy}}
   - name: {{appName}}-mtx
     type: nodejs
     path: {{#isNodejs}}gen/{{/isNodejs}}mtx/sidecar
@@ -66,7 +66,7 @@ modules:
       - name: app-api
         properties:
           SUBSCRIPTION_URL: ~{app-protocol}://\${tenant_subdomain}-~{app-uri}
-  {{/isMultitenant}}
+  {{/hasMultitenancy}}
 
 resources:
   - name: {{appName}}-auth
@@ -77,4 +77,4 @@ resources:
       path: ./xs-security.json
       config:
         xsappname: {{appName}}-${org}-${space}
-        tenant-mode: {{#isMultitenant}}shared{{/isMultitenant}}{{^isMultitenant}}dedicated{{/isMultitenant}}
+        tenant-mode: {{#hasMultitenancy}}shared{{/hasMultitenancy}}{{^hasMultitenancy}}dedicated{{/hasMultitenancy}}