@sap/cds-dk 7.4.0 → 7.5.0

package/lib/init/index.js

@@ -5,17 +5,17 @@ const term = require('../util/term');
 const { OPTIONS, COMMAND_INIT, PROJECT_FILES, REGEX_PROJECT_NAME } = require('./constants')
 const {
     NODEJS, JAVA,
-    HANA, APPROUTER, XSUAA, KIBANA, ENTERPRISE_MESSAGING,
+    HANA, APPROUTER, XSUAA, APPLICATION_LOGGING, ENTERPRISE_MESSAGING,
     MTA, MULTITENANCY, PIPELINE,
     TINY_SAMPLE, SAMPLE
  } = OPTIONS
 
-const cds = require('../cds'), { exists, readdir } = cds.utils
+const cds = require('..'), { exists, readdir } = cds.utils
 const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) ? console.debug : undefined
 
 module.exports = class CDSGenerator {
     constructor() {
-        this.cwd = process.cwd();
+        this.cwd = process.cwd()
 
         this.uiConfig = [{
             title: 'Project Name',
@@ -60,7 +60,7 @@ module.exports = class CDSGenerator {
                 { name: 'SAP HANA Cloud', value: HANA },
                 { name: 'SAP Application Router', value: APPROUTER },
                 { name: 'User Authentication via XSUAA', value: XSUAA },
-                { name: 'Kibana Logging Dashboard', value: KIBANA },
+                { name: 'Application Logging', value: APPLICATION_LOGGING },
                 { name: 'SAP BTP Event Mesh', value: ENTERPRISE_MESSAGING }
             ],
             multiple: true,
@@ -133,9 +133,12 @@ module.exports = class CDSGenerator {
                 // keep caller independent from internal names
                 options: {
                     cwd: options.cwd,
-                    add: options.add
+                    add: new Set(options.add)
                 }
             }
+
+            // must be called after above code to ensure cds.cli.options.add is set
+            cds.add = require('./add')
         }
 
         this._initialize(projectName);
@@ -176,8 +179,8 @@ module.exports = class CDSGenerator {
         for (const template of this.templateList) {
             console.log(`Adding feature '${template.name}'...`);
             await template.run();
-            await template.runDependentMerging();
-            await template.runRelatedMerging();
+            await template.combine();
+            await template.combineSupported();
         }
 
         if (cds.cli.command === COMMAND_INIT) {
@@ -192,10 +195,10 @@ module.exports = class CDSGenerator {
         }
     }
 
-    async _createTemplate(filename) {
+    async _createTemplate(plugin) {
         try {
-            const TemplateClass = require(`./template/${filename}`);
-            return new TemplateClass(this);
+            const Plugin = cds.add.registered.get(plugin) ?? require(`./template/${plugin}`)
+            return new Plugin(this)
         } catch (err) {
             if (err.code === 'MODULE_NOT_FOUND') {
                 const entries = (await readdir(path.join(__dirname, 'template')))
@@ -205,11 +208,11 @@ module.exports = class CDSGenerator {
                         entry !== 'nodejs' &&
                         entry !== 'java'
                     );
-                const fuzzySearch = require('../../bin/util/fuzzySearch');
-                const [bestMatch] = fuzzySearch(filename, entries);
-                throw `Unknown facet '${term.bold(filename)}'. Did you mean ${term.bold(`cds add ${bestMatch}`)}?\n\nHaven't found the proper facet yet? Here are all supported facets:\n\n  ${term.bold(entries.join('\n  '))}\n`
+                const fuzzySearch = require('../../bin/util/fuzzySearch')
+                const [bestMatch] = fuzzySearch(plugin, entries)
+                throw `Unknown facet '${term.bold(plugin)}'. Did you mean ${term.bold(`cds add ${bestMatch}`)}?\n\nHaven't found the proper facet yet? Here are all supported facets:\n\n  ${term.bold(entries.join('\n  '))}\n`
             }
-            throw err;
+            throw err
         }
     }
 
@@ -217,28 +220,39 @@ module.exports = class CDSGenerator {
         const templates = new Map
         const { command, options, argv } = cds.cli
 
-        const facets = command === COMMAND_INIT ? options.add : new Set(argv[0].split(','))
+        const plugins = command === COMMAND_INIT ? options.add : new Set(argv[0].split(','))
 
-        for (let facet of facets) {
+        for (let plugin of plugins) {
             // Compat
-            if (facet === 'sample-tiny') facet = 'tiny-sample'
-            if (facet === 'kibana-logging') facet = 'kibana'
-            if (facet === 'postgresql') facet = 'postgres'
+            if (plugin === 'helm' && cds.cli.options['internal-unified-runtime-charts']) {
+                plugin = 'helm-unified-runtime'
+                cds.cli.options.add.delete('helm')
+                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 === 'postgresql') plugin = 'postgres'
 
-            if (!templates.has(facet)) {
-                const template = await this._createTemplate(facet)
+            if (!templates.has(plugin)) {
+                const template = await this._createTemplate(plugin)
                 if (await template.canRun()) {
                     DEBUG?.(`Adding feature '${template.name}'`)
-                    templates.set(facet, template)
-                    const dependencies = await template.getDependencies()
-                    dependencies?.forEach(d => facets.add(d))
+                    templates.set(plugin, template)
+                    const dependencies = await template.requires()
+                    dependencies?.forEach(d => plugins.add(d))
                 }
             }
         }
 
         const cmds = Object.values(OPTIONS)
         this.templateList = Array.from(templates.entries())
-            .sort(([a], [b]) => cmds.indexOf(a) - cmds.indexOf(b))
+            .sort(([lhs], [rhs]) => {
+                const a = cmds.indexOf(lhs), b = cmds.indexOf(rhs)
+                if (a === -1 && b === -1) return 0
+                if (a === -1) return 1
+                if (b === -1) return -1
+                return a - b
+            })
             .map((entry) => entry[1])
 
         // check debug to avoid lengthy computation when not in debug mode

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
+}