@sap/cds-dk 6.0.4 → 6.1.1

package/lib/init/util/projectReader.js

@@ -63,6 +63,7 @@ module.exports = class ProjectReader {
     }
 
     async _getCapDescriptor(env, options) {
+        const projectPath = this.projectPath
         let capDescriptor = {
             for: options && options.for,
             pLanguage: DEFAULT_P_LANGUAGE,
@@ -70,12 +71,17 @@ module.exports = class ProjectReader {
             db: [],
             requires: [],
             get isMultitenant() {
-                return options && options.add && options.add.has('mtx') ||
+                return options?.add?.has('mtx') || options?.add?.has('multitenancy') ||
                     env.requires.multitenancy ||
-                    env.requires.db && env.requires.db.multiTenant ||
-                    this.isJava && fs.existsSync('mtx-sidecar') ||
+                    env.requires.db?.multiTenant ||
+                    this.isJava && fs.existsSync(path.join('mtx', 'sidecar')) ||
                     false
             },
+            get isExtensible() {
+                const sidecarPackage = path.join('mtx', 'sidecar', 'package.json')
+                return options?.add?.has('mtx') || options?.add?.has('extensibility') || env.requires.extensibility ||
+                    fs.existsSync(sidecarPackage) && JSON.parse(fs.readFileSync(sidecarPackage, 'utf8')).cds.requires.extensibility === true
+            },
             get isNodejs() {
                 return this.pLanguage === P_LANGUAGE_NODEJS
             },
@@ -99,6 +105,9 @@ module.exports = class ProjectReader {
             },
             get hasApprouter() {
                 return !!env.requires.approuter
+            },
+            get hasMtaDeployment() {
+                return fs.existsSync(path.join(projectPath, 'mta.yaml'))
             }
         }
 
@@ -392,7 +401,6 @@ module.exports = class ProjectReader {
                 // use different service name to avoid conflicts when switching from single tenant to multitenant
                 // otherwise we would enforce that users have to delete the db container first
                 if (resource.isMultitenant) {
-                    //resource.name += '-mt'
                     resource.service = 'service-manager'
                     resource.vcap.plan = 'container'
                 } else {
@@ -402,9 +410,6 @@ module.exports = class ProjectReader {
                 break
 
             case 'xsuaa':
-                // if (capDescriptor.isMultitenant) {
-                //     resource.name += '-mt'
-                // }
                 resource.service = reqEntry.kind
                 resource.vcap.plan = 'application'
                 break

package/lib/init/util/templateUtil.js

@@ -68,31 +68,29 @@ module.exports = class TemplateUtil {
     just maps where you can do a key-value replacement.
     */
     _deepMerge(target, source) {
+        const unique = array => [...new Set(array.map(JSON.stringify))].map(JSON.parse)
         if (this._isObject(target) && this._isObject(source)) {
             for (const key in source) {
                 if (this._isObject(source[key])) {
-                    if (!target[key]) Object.assign(target, { [key]: source[key] });
-                    if ('#overwrite' in source[key]) Object.assign(target, { [key]: source[key]["#overwrite"] })
-                    else this._deepMerge(target[key], source[key]);
+                    if (!target[key]) Object.assign(target, { [key]: source[key] })
+                    else this._deepMerge(target[key], source[key])
                 } else if (Array.isArray(source[key]) && Array.isArray(target[key])) {
-                    const unique = array => [...new Set(array.map(JSON.stringify))].map(JSON.parse);
                     target[key] = unique([...source[key], ...target[key]])
                 } else {
-                    Object.assign(target, { [key]: target[key] || source[key] });
+                    Object.assign(target, { [key]: target[key] || source[key] })
                 }
             }
         } else if (Array.isArray(target) && Array.isArray(source)) {
-            const unique = array => [...new Set(array.map(JSON.stringify))].map(JSON.parse);
             target = unique([...source, ...target])
         }
-        return target || source;
+        return target || source
     }
 
     async mergeJSON(targetPath, from, projectDescriptor, semantics) {
         const source = typeof from === 'string' ? await this.fsUtil.readJSON(from, projectDescriptor) : from
 
         if (! await this.fsUtil.pathExists(targetPath)) {
-            await this.fsUtil.writeJSON(targetPath, source);
+            await this.fsUtil.writeJSON(targetPath, source)
         } else if (semantics) {
             const target = await this.fsUtil.readJSON(targetPath)
 
@@ -104,11 +102,11 @@ module.exports = class TemplateUtil {
             const result = YAML.parse(YAML.stringify(resultYAML))
             await this.fsUtil.writeJSON(targetPath, result)
         } else {
-            const target = await this.fsUtil.readJSON(targetPath);
-            const sourceFile = await this._processTemplateFile(from, projectDescriptor);
-            const source = JSON.parse(sourceFile);
-            const result = target && source ? this._deepMerge(target, source) : target || source;
-            await this.fsUtil.writeJSON(targetPath, result);
+            const target = await this.fsUtil.readJSON(targetPath)
+            const sourceFile = await this._processTemplateFile(from, projectDescriptor)
+            const source = JSON.parse(sourceFile)
+            const result = target && source ? this._deepMerge(target, source) : target || source
+            await this.fsUtil.writeJSON(targetPath, result)
         }
     }
 
@@ -121,98 +119,95 @@ module.exports = class TemplateUtil {
         const existenceMap = new Map()
         const templateExistenceMap = new Map()
 
-        const existences = semantics.existences && semantics.existences.filter(e => e)
-
-        existences && existences.forEach(existence => {
+        const { additions, overwrites, deletions, relationships } = semantics
+        additions?.forEach(existence => {
             existenceMap.set(existence.ref, undefined)
             templateExistenceMap.set(existence.ref, undefined)
-        });
-
-        const { deletions } = semantics
-        deletions && deletions.forEach(deletion => {
-            existenceMap.set(deletion.existence.ref, undefined)
         })
-
-        const missingRelationshipsMap = new Map()
-
-        const relationships = semantics.relationships && semantics.relationships.filter(r => r)
-        relationships && relationships.forEach(relationship =>
-            missingRelationshipsMap.set(relationship.in.ref, undefined)
-        )
+        deletions?.forEach(deletion => {
+            existenceMap.set(deletion.item.ref, undefined)
+        })
+        relationships?.forEach(relationship => {
+            const [existence] = relationship.into
+            const [insertExistence] = relationship.insert
+            const ref = insertExistence.ref + ' -> ' + existence.ref
+            existenceMap.set(ref, undefined)
+        })
 
         let collectionStack = [target.contents]
 
-        const _getProperty = (object, keyPath) => keyPath.reduce((p, n) => p && p[n], object)
-        const _getYAMLProperty = (object, keyPath) => keyPath.reduce((p, n) => p && p.get(n), object)
-
-        const _validateConstraints = (node, dict, index) => {
-            const _addToMap = existences => existences && existences
-                .filter(existence => {
-                    if (!existence.in) return true
-                    const neededParent = existence.in && dict.get(existence.in.ref) && dict.get(existence.in.ref).node
-                    return collectionStack.includes(neededParent)
-                })
-                .forEach(existence => {
-                    const json = JSON.parse(String(node));
-                    const constraintsFulfilled = existence.constraints.every(constraint =>
-                        constraint.value === _getProperty(json, constraint.comparisonKeyPath)
-                    )
-                    if (constraintsFulfilled) {
-                        const [collection] = collectionStack
-                        dict.set(existence.ref, { json, node, index, collection })
-                    }
+        const _getProperty = (object, keyPath) => keyPath.split('.').reduce((p, k) => p && p[k], object)
+        const _getYAMLProperty = (object, keyPath) => keyPath.split('.').reduce((p, k) => p && p.get(k), object)
+
+        const _validateWhere = (node, dict, index) => {
+            const _addToMap = existences => existences?.filter(existence => {
+                    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
+                    return collectionStack.includes(neededParent) // lookbehind in parent collection stack
+                    // REVISIT: Only look behind until sequence is reached?
+            }).forEach(({ where, ref }) => {
+                const json = JSON.parse(String(node))
+                const whereFulfilled = where.every(constraint =>
+                    constraint.isEqualTo === _getProperty(json, constraint.property)
+                )
+                if (whereFulfilled) {
+                    const [collection] = collectionStack
+                    dict.set(ref, { json, node, index, collection })
+                }
             })
-            _addToMap(existences)
-            deletions && _addToMap(deletions.map(deletion => deletion.existence))
+            if (additions) _addToMap(additions)
+            if (deletions) _addToMap(deletions.map(deletion => deletion.item))
+            if (relationships) _addToMap(relationships?.map(({into: [existence]}) => existence).filter(e => e))
         }
 
         function _traverseYAMLNode(node, index, actions, templateNode) {
             let shifted = false
             if (YAML.isMap(node)) {
-                actions && actions.visitMap && actions.visitMap(node, index)
+                actions?.visitMap && actions.visitMap(node, index)
                 const [collection] = collectionStack
                 if (YAML.isSeq(collection)) {
                     collectionStack.unshift(node)
                     shifted = true
                 }
-            } else if (YAML.isPair(node) && node.value && node.value.items) {
+            } else if (YAML.isPair(node) && node.value?.items) {
                 collectionStack.unshift(node.value)
             } else if (YAML.isScalar(node) && semantics.forceOverwrite && templateNode) {
                 node.value = templateNode.value
             }
 
             if (node.items) {
-                if (YAML.isSeq(node) && templateNode && templateNode.items) {
-                    actions.mergeCollection && actions.mergeCollection(node, templateNode)
+                if (YAML.isSeq(node) && templateNode?.items) {
+                    actions?.mergeCollection && actions.mergeCollection(node, templateNode)
                     _traverseYAMLCollection(node, actions, templateNode)
                 } else {
                     _traverseYAMLCollection(node, actions, templateNode)
                 }
-            } else if (node.value && node.value.items || node.value && semantics.forceOverwrite) {
+            } else if (node.value?.items || node.value && semantics.forceOverwrite) {
                 _traverseYAMLNode(node.value, index, actions, templateNode && templateNode.value)
             }
 
-            if (node.value && node.value.items || shifted) {
+            if (node.value?.items || shifted) {
                 collectionStack.shift()
             }
         }
         _traverseYAMLNode.bind(this)
 
-        const _traverseYAMLCollection = (collection, actions, templateCollection) => {
+        function _traverseYAMLCollection (collection, actions, templateCollection) {
             if (!collection) return
 
-            const keyIndexMap = new Map()
-            const templateIndexMap = new Map()
+            const keyToIndex = new Map, templateIndexToIndex = new Map
 
             // Map collection items to their semantic counterpart(s)
             collection.items.forEach((node, i) => {
-                if (node.key) keyIndexMap.set(node.key.value, i)
-                const existence = [...existenceMap.entries()].find(([,value]) => value && value.node === node)
+                if (node.key) keyToIndex.set(node.key.value, i)
+                const existence = [...existenceMap.entries()].find(([,value]) => value?.node === node)
                 if (existence) {
                     const [existenceKey] = existence
                     const templateExistence = existenceKey && templateExistenceMap.get(existenceKey)
-                    const templateIndex = templateExistence && templateExistence.index
-                    if (templateIndex !== undefined) templateIndexMap.set(templateIndex, i)
+                    const templateIndex = templateExistence?.index
+                    if (templateIndex !== undefined) templateIndexToIndex.set(templateIndex, i)
                 }
                 if (!templateCollection) _traverseYAMLNode(node, i, actions)
             })
@@ -220,8 +215,12 @@ module.exports = class TemplateUtil {
             if (!templateCollection) return
 
             templateCollection.items.forEach((templateNode, templateIndex) => {
-                if (YAML.isPair(templateNode)) {
-                    const i = keyIndexMap.get(templateNode.key.value)
+                if (YAML.isScalar(templateNode)) {
+                    if (!collection.items.map(item => item.value).includes(templateNode.value)) {
+                        collection.add(templateNode)
+                    }
+                } else if (YAML.isPair(templateNode)) {
+                    const i = keyToIndex.get(templateNode.key.value)
                     const [collection] = collectionStack
                     const targetNode = collection.items && collection.items[i]
                     if (targetNode) {
@@ -230,10 +229,10 @@ module.exports = class TemplateUtil {
                         actions.mergePair(collection, templateNode)
                     }
                 } else if (YAML.isMap(templateNode)) {
-                    const targetNode = collection.items[templateIndexMap.get(templateIndex)]
+                    const targetNode = collection.items[templateIndexToIndex.get(templateIndex)]
                     if (actions.mergeCollection) actions.mergeCollection(targetNode, templateNode)
                     if (targetNode) {
-                        _traverseYAMLNode(targetNode, templateIndex, actions, templateNode);
+                        _traverseYAMLNode(targetNode, templateIndex, actions, templateNode)
                     }
                 }
             })
@@ -243,42 +242,43 @@ module.exports = class TemplateUtil {
         // 1. Validate the existences in the template
         _traverseYAMLNode(source.contents, null, {
             visitMap: (node, index) => {
-                _validateConstraints(node, templateExistenceMap, index)
+                _validateWhere(node, templateExistenceMap, index)
             }
         })
 
         // 2. Validate the existences in the project
         _traverseYAMLNode(target.contents, null, {
             visitMap: (node, index) => {
-                _validateConstraints(node, existenceMap, index)
+                _validateWhere(node, existenceMap, index)
             }
         })
 
         // 3. Apply overwrites to already found existences
-        semantics.overwrites && semantics.overwrites.forEach(({ in: inExistence, keyPath, replacement }) => {
-            const existence = existenceMap.get(inExistence.ref)
-            if (existence) {
-                _getYAMLProperty(existence.node, keyPath.slice(0, keyPath.length - 1))
-                    .set(keyPath[keyPath.length - 1], replacement)
-            }
+        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 keys = keyPath.split('.')
+            if (!node.getIn(keys)) return
+            _getYAMLProperty(node, keys.slice(0, keys.length - 1).join('.'))
+                .set(keys[keys.length - 1], withValue)
         })
 
         // 4. Delete existences from the project (e.g. separate deployer module when adding mtx)
-        semantics.deletions && semantics.deletions.forEach(({ existence: { ref }, relationships }) => {
+        deletions?.forEach(({ item: { ref }, relationships }) => {
             const existence = existenceMap.get(ref)
             if (!existence) return
             existence.collection.delete(existence.index)
 
-            relationships && relationships.forEach(relationship => {
-                const parent = _getYAMLProperty(target, relationship.allWithinKeyPath)
+            relationships?.forEach(relationship => {
+                const [allWithinKeyPath, inKeyPath, into] = relationship.allWithin
+                const parent = _getYAMLProperty(target, allWithinKeyPath)
                 for (const child of parent.items) {
-                    const c = _getYAMLProperty(child, relationship.inKeyPath)
-                    const i = c.items.findIndex(node =>
-                        node.get(relationship.into) === _getProperty(existence.json, relationship.existenceKeyPath)
-                    )
-                    if (i > -1) {
-                        c.delete(i)
-                    }
+                    const grandchild = _getYAMLProperty(child, inKeyPath)
+                    const i = grandchild?.items?.findIndex(node =>
+                        node.get(into) === _getProperty(existence.json, relationship.removeProperty)
+                    ) ?? - 1
+                    if (i > -1) grandchild.delete(i)
                 }
             })
         })
@@ -286,33 +286,32 @@ module.exports = class TemplateUtil {
         // 5. Create missing existences and pairs
         _traverseYAMLNode(target.contents, null, {
             mergePair: (collection, templateNode) => {
-                const childIsArray = false//templateNode.value.type !== 'MAP' && !!templateNode.value.items
-                if (YAML.isMap(collection) && !childIsArray) {
+                if (YAML.isMap(collection)) {
                     collection.add(templateNode)
                 }
             },
             mergeCollection: (targetNode, templateNode) => {
                 if (YAML.isSeq(templateNode)) {
                     let [,parent] = collectionStack
-                    const missingExistences = semantics.existences
-                        .filter(e => e)
-                        .filter(existence => {
-                            const requiredParent = existence.in &&
-                                                   existenceMap.get(existence.in.ref) &&
-                                                   existenceMap.get(existence.in.ref).node
-                            return !existence.in || requiredParent === parent
-
+                    additions?.filter(existence => {
+                            if (typeof existence.in === 'string' || Array.isArray(existence.in) && typeof existence.in[0] === 'string') return true
+                            const inExistence = Array.isArray(existence.in) ? existenceMap.get(existence.in[0].ref) : existenceMap.get(existence.in.ref)
+                            return inExistence?.node === parent
                         })
-                        .filter(({keyPath}) => {
-                            if (keyPath.length > collectionStack.length + 1) return
-                            if (keyPath.length > 1) parent = collectionStack[keyPath.length]
+                        .filter(existence => {
+                            const keyPath = typeof existence.in === 'string' ? existence.in : Array.isArray(existence.in) && typeof existence.in[0] === 'string' ? existence.in[0] : existence.in[1]
+                            const keys = keyPath.split('.')
+                            if (keys.length > collectionStack.length + 1) return
+                            if (keys.length > 1) parent = collectionStack[keys.length]
                             return _getYAMLProperty(parent, keyPath) === targetNode
                         })
-                        .filter(({ref}) => !existenceMap.get(ref))
-                    missingExistences.forEach(existence => {
-                        const templateNode = templateExistenceMap.get(existence.ref).node
-                        targetNode.add(templateNode)
-                    })
+                        .filter(({ ref }) => {
+                            return !existenceMap.get(ref)
+                        })
+                        .forEach(({ ref }) => {
+                            const templateNode = templateExistenceMap.get(ref).node
+                            targetNode.add(templateNode)
+                        })
                 }
             },
         }, source.contents)
@@ -320,7 +319,7 @@ module.exports = class TemplateUtil {
         // 6. Re-validate the existences in the project
         _traverseYAMLNode(target.contents, null, {
             visitMap: (node, index) => {
-                _validateConstraints(node, existenceMap, index)
+                _validateWhere(node, existenceMap, index)
             }
         })
 
@@ -329,23 +328,26 @@ module.exports = class TemplateUtil {
             mergeCollection: (targetNode, templateNode) => {
                 if (YAML.isSeq(templateNode)) {
                     const targetJSON = YAML.parse(String(targetNode))
-                    const relationship = semantics.relationships && semantics.relationships
-                        .filter(r => r)
+                    const relationship = semantics.relationships?.filter(r => r)
                         .find(relationship => {
-                            const existingNode = _getYAMLProperty(existenceMap.get(relationship.in.ref).node, relationship.inKeyPath)
+                            const [existence, keyPath] = relationship.into
+                            if (!existenceMap.get(existence.ref)) return false
+                            const existingNode = _getYAMLProperty(existenceMap.get(existence.ref).node, keyPath)
                             return targetNode === existingNode
                     })
                     if (!relationship) return
 
-                    const missingPairs = relationship.existences
+                    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, relationship.existenceKeyPath) === item[relationship.into]
+                                _getProperty(existenceMap.get(ref).json, existenceKeyPath) === item[intoKey]
                             )
                         )
-                        .map(({ref}) => existenceMap.get(ref).node.get(relationship.into))
+                        .map(({ref}) => existenceMap.get(ref).node.get(intoKey))
                     missingPairs.forEach(pair => {
-                        targetNode.add({ [relationship.into]: pair })
+                        targetNode.add({ [intoKey]: pair })
                     })
                 }
             }

package/lib/k8s/ChartAdder.js

@@ -1,6 +1,7 @@
 
 
 const { yaml } = require('./modules');
+const path = require('path');
 const fs = require('fs').promises;
 const FsUtil = require('../../lib/init/util/fsUtil')
 const TemplateUtil = require('../../lib/init/util/templateUtil')
@@ -10,9 +11,9 @@ class ChartAdder {
      *
      * @param {{ builder: import('./ChartBuilder') }} param0
      */
-    constructor({ builder, template, chartValues, chartDependencies, app, mergeSemantics }) {
+    constructor({ builder, resources, chartValues, chartDependencies, app, mergeSemantics }) {
         this.builder = builder;
-        this.template = template;
+        this.resources = resources;
         this.chartValues = chartValues;
         this.app = app;
         this.mergeSemantics = mergeSemantics;
@@ -22,12 +23,19 @@ class ChartAdder {
 
     async execute() {
         await this.copyTemplates();
+        await this.copySchema();
         await this.addChartValues();
         await this.addChartFile();
     }
 
     async copyTemplates() {
-        await this.builder.addAllTemplates(this.template);
+        await this.builder.addAllTemplates(this.resources);
+    }
+
+    async copySchema() {
+        let schema = JSON.parse(await fs.readFile(path.join(this.resources, 'values.schema.json'), { encoding: 'utf8' }))
+
+        await this.builder.writeChartFile('values.schema.json', JSON.stringify(schema, null, 4));
     }
 
     async addChartValues() {

package/lib/k8s/ChartBuilder.js

@@ -51,6 +51,12 @@ class ChartBuilder {
 
             await this.templateUtil.mergeYAML(filePath, newYamlContent, null, mergeSemantics);
         } else {
+
+            const header = `
+# yaml-language-server: $schema=./values.schema.json
+
+`
+            data = header + data;
             await this.writeChartFile(fileName, data);
         }
 

package/lib/k8s/buildModel.js

@@ -34,9 +34,7 @@ async function buildModel(context) {
         return {
             global: {
                 domain: null,
-                imagePullSecret: {
-                    name: null
-                }
+                imagePullSecret: {}
             }
         }
     };

package/lib/k8s/connectivity/index.js

@@ -50,12 +50,12 @@ module.exports = wrapFeature('connectivity', {
             }
         );
 
-        mergeSemantics.existences.push({
+        mergeSemantics.additions.push({
             ref: `{name}-additional-volumes`,
-            keyPath: [name, "additionalVolumes"],
-            constraints: [{
-                comparisonKeyPath: ["name"],
-                value: "connectivity-secret"
+            in: `${name}.additionalVolumes`,
+            where: [{
+                property: 'name',
+                isEqualTo: 'connectivity-secret'
             }]
         });
     },

package/lib/k8s/deployment/index.js

@@ -19,7 +19,7 @@ class Deployment {
 
         const language = this.language || model.language;
         const memory = language === 'Java' ? '1G' : '500M';
-        const cpu = language === 'Java' ? '700m' : '100m';
+        const cpu = language === 'Java' ? '1000m' : '500m';
         const env = language === 'Java' ? {SPRING_PROFILES_ACTIVE: "cloud"} : undefined;
 
         return {
@@ -32,12 +32,11 @@ class Deployment {
                 env,
                 resources: {
                     limits: {
-                        cpu,
                         'ephemeral-storage': '1G',
                         memory
                     },
                     requests: {
-                        cpu: '100m',
+                        cpu,
                         'ephemeral-storage': '1G',
                         memory
                     }
@@ -64,7 +63,6 @@ class Deployment {
 
     async addToChart(builder) {
         await builder.addSubchartFiles(webApplicationChartPath, 'web-application');
-        await builder.addChartFile(Path.join(__dirname, 'subchart-override', 'templates', '_web_application_helpers.tpl'), {fileName: Path.join('charts', 'web-application', 'templates', '_web_application_helpers.tpl')});
     }
 }
 

package/lib/k8s/deployment/subchart/Chart.yaml

@@ -1,6 +1,6 @@
 apiVersion: v2
 name: web-application
 description: A Helm chart for web app
-
+kubeVersion: ">= 1.21"
 type: application
 version: 0.1.0

package/lib/k8s/deployment/subchart/templates/_helpers.tpl

@@ -81,13 +81,20 @@ Define Host for the APIRule
 {{- end }}
 {{- end }}
 
+{{/*
+Define the application uri which will be used for the VCAP_APPLICATION env variable
+*/}}
+{{- define "web-application.applicationUri" -}}
+{{- include "web-application.fullname" . }}
+{{- end }}
+
 {{/*
 Service Binding secret mounts
 */}}
 {{- define "web-application.serviceMounts" -}}
 {{- range $name, $params := .Values.bindings }}
 - mountPath: /bindings/{{ $name }}/
-  name: "{{ $name }}-binding"
+  name: "{{ $name }}"
   readOnly: true
 {{- end }}
 {{- end }}
@@ -103,18 +110,9 @@ Service Binding secret volumes
 {{- else if $params.secretName }}
 {{- $secretName = $params.secretName }}
 {{- end }}
-- name: {{ $name }}-binding
+- name: {{ $name }}
   secret:
     secretName: {{ $secretName }}
-    items:
-    - key: label
-      path: metadata/label
-    - key: plan
-      path: metadata/plan
-    - key: tags
-      path: metadata/tags
-    - key: credentials
-      path: credentials
 {{- end }}
 {{- end }}
 
@@ -132,6 +130,19 @@ Name of the imagePullSecret
 {{- end }}
 {{- end }}
 
+{{/*
+Calculate the final image name
+*/}}
+{{- define "web-application.imageName" -}}
+{{- $tag := .Values.image.tag | default .Values.global.image.tag | default "latest" }}
+{{- $registry := .Values.image.registry | default .Values.global.image.registry }}
+{{- if $registry }}
+{{- $registry | trimSuffix "/" }}/{{ .Values.image.repository }}:{{ $tag }}
+{{- else }}
+{{- .Values.image.repository }}:{{ $tag }}
+{{- end }}
+{{- end }}
+
 {{/*
 Create the name of a service instance.
 We truncate at 63 chars because some Kubernetes name fields are limited to this (by the DNS naming spec).