@sap/cds-dk 6.0.4 → 6.1.3

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

@@ -1,9 +1,8 @@
-const fs = require('fs')
 const path = require('path')
 const TemplateBase = require('../templateBase')
 const ProjectReader = require('../../util/projectReader')
-const { srvNode, srvJava, xsuaa } = require('../_merging/existences')
-const { PROJECT_TYPE, OPTION_HELM_UPDATE } = require('../../constants');
+const { srvNode, srvJava, xsuaa, mtxSidecar } = require('../_merging/registry-mta')
+const { PROJECT_TYPE, OPTION_HELM_UPDATE } = require('../../constants')
 
 module.exports = class XsuaaTemplate extends TemplateBase {
     constructor(projectPath, generator) {
@@ -13,35 +12,46 @@ module.exports = class XsuaaTemplate extends TemplateBase {
 
     async runDependentMerging() {
         const projectDescriptor = await this.projectReader.read(this.options)
-        const { projectPath } = this
+        const { isMultitenant, isExtensible, hasMtaDeployment, isNodejs, isJava } = projectDescriptor.cap
 
-        const mtaYAMLPath = path.join(projectPath, 'mta.yaml')
-        if (!fs.existsSync(mtaYAMLPath)) return
+        if (hasMtaDeployment) {
+            const srv = isNodejs ? srvNode : srvJava
+            const additions = [srv, xsuaa]
+            if (isMultitenant && isJava) additions.push(mtxSidecar)
 
-        const srv = projectDescriptor.cap.isNodejs ? srvNode : srvJava
-        await this.templateUtil.mergeYAML(
-            mtaYAMLPath,
-            `${__dirname}/files/mta.yaml.hbs`,
-            projectDescriptor,
-            {
-                existences: [srv, xsuaa],
-                relationships: [{
-                    in: srv,
-                    inKeyPath: ["requires"],
-                    into: "name",
-                    existences: [xsuaa],
-                    existenceKeyPath: ["name"],
-                }],
-            }
-        )
+            const mtaYAMLPath = path.join(this.projectPath, 'mta.yaml')
+            const relationships =  [{
+                insert: [xsuaa, 'name'],
+                into: [srv, 'requires', 'name']
+            }]
+            relationships.push({
+                insert: [xsuaa, 'name'],
+                into: [mtxSidecar, 'requires', 'name']
+            })
+
+            await this.templateUtil.mergeYAML(
+                mtaYAMLPath,
+                `${__dirname}/files/mta.yaml.hbs`,
+                projectDescriptor,
+                {
+                    additions,
+                    relationships
+                }
+            )
+        }
 
         // Re-applying the merging part of `cds add mtx` because cds.compile.to.xsuaa
         // has overwritten the existing `xs-security.json`.
         // TODO: Find a generic solution for situation like these.
-        if (projectDescriptor.cap.isMultitenant) {
-            const MtxTemplate = require(`../mtx`)
-            const mtxTemplate = new MtxTemplate(this.projectPath, this.generator)
-            await mtxTemplate.runDependentMerging()
+        if (isMultitenant) {
+            const MultitenancyTemplate = require(`../multitenancy`)
+            const multitenancyTemplate = new MultitenancyTemplate(this.projectPath, this.generator)
+            await multitenancyTemplate.runDependentMerging()
+        }
+        if (isExtensible) {
+            const ExtensibilityTemplate = require(`../extensibility`)
+            const extensibilityTemplate = new ExtensibilityTemplate(this.projectPath, this.generator)
+            await extensibilityTemplate.runDependentMerging()
         }
     }
 
@@ -49,19 +59,20 @@ module.exports = class XsuaaTemplate extends TemplateBase {
         const { projectPath } = this
         const templatePath = path.join(__dirname, 'files')
         const projectDescriptor = await this.projectReader.read(this.options)
+        const { for: forProfile } = projectDescriptor.cap
 
         const projectType = await this.getProjectType();
         switch (projectType) {
             case PROJECT_TYPE.java: {
                 const cdsrcJSONPath = path.join(projectPath, '.cdsrc.json')
-                const cdsTemplateFile = projectDescriptor.cap.for ? 'cds.cdsrc.json.hbs' : 'cds.cdsrc.json'
+                const cdsTemplateFile = forProfile ? 'cds.cdsrc.json.hbs' : 'cds.cdsrc.json'
                 const cdsTemplatePath = path.join(templatePath, cdsTemplateFile)
                 await this.templateUtil.mergeJSON(cdsrcJSONPath, cdsTemplatePath, projectDescriptor)
                 break
             }
             case PROJECT_TYPE.nodejs: {
                 const packageJSONPath = path.join(projectPath, 'package.json')
-                const cdsTemplateFile = projectDescriptor.cap.for ? 'cds.package.json.hbs' : 'cds.package.json'
+                const cdsTemplateFile = forProfile ? 'cds.package.json.hbs' : 'cds.package.json'
                 const cdsTemplatePath = path.join(templatePath, cdsTemplateFile)
                 await this.templateUtil.mergeJSON(packageJSONPath, cdsTemplatePath, projectDescriptor)
                 const dependenciesTemplatePath = path.join(templatePath, 'dependencies.package.json')
@@ -76,12 +87,12 @@ module.exports = class XsuaaTemplate extends TemplateBase {
         } catch (error) { /* ignore */ }
         })() || { scopes: [], attributes: [], 'role-templates': [], 'authorities-inheritance': false }
 
-        const mergingSemantics = { existences: xsuaa.scopes.map(scope => ({
+        const mergingSemantics = { additions: xsuaa.scopes.map(scope => ({
             ref: scope.name,
-            keyPath: ["scopes"],
-            constraints: [{
-                comparisonKeyPath: ["name"],
-                value: scope.name
+            in: 'scopes',
+            where: [{
+                property: 'name',
+                isEqualTo: scope.name
             }],
         }))}
         const xsSecurityPath = path.join(projectPath, 'xs-security.json')

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
+                node.value = templateNode.value ?? templateNode.items?.[0]?.value?.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(addition => {
+                            if (typeof addition.in === 'string' || Array.isArray(addition.in) && typeof addition.in[0] === 'string') return true
+                            const inExistence = Array.isArray(addition.in) ? existenceMap.get(addition.in[0].ref) : existenceMap.get(addition.in.ref)
+                            return inExistence?.node === parent
                         })
-                        .filter(({keyPath}) => {
-                            if (keyPath.length > collectionStack.length + 1) return
-                            if (keyPath.length > 1) parent = collectionStack[keyPath.length]
+                        .filter(addition => {
+                            const keyPath = typeof addition.in === 'string' ? addition.in : Array.isArray(addition.in) && typeof addition.in[0] === 'string' ? addition.in[0] : addition.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, at }) => {
+                            const templateNode = templateExistenceMap.get(ref).node
+                            at !== undefined ? targetNode.items.splice(at, 0, templateNode) : 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,21 @@ 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 valuesSchema = JSON.parse(await fs.readFile(path.join(this.resources, 'schemas', 'values.schema.json'), { encoding: 'utf8' }))
+        let valuesRootSchema = JSON.parse(await fs.readFile(path.join(this.resources, 'schemas', 'values.root.schema.json'), { encoding: 'utf8' }))
+
+        await this.builder.writeChartFile('values.schema.json', JSON.stringify(valuesSchema, null, 4));
+        await this.builder.writeChartFile('values.root.schema.json', JSON.stringify(valuesRootSchema, 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.root.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: {}
             }
         }
     };