@sap/cds-dk 8.7.3 → 8.8.1

package/lib/bind/shared.js

@@ -0,0 +1,267 @@
+const os = require('node:os')
+const cds = require('../cds')
+const { exists, read, fs, path } = cds.utils
+const git = require('../util/git')
+const { bold } = require('../util/term')
+
+const KindToRequiresNameMap = {
+    xsuaa: 'auth',
+    'xsuaa-auth': 'auth',
+    'ias-auth': 'auth',
+    'hana-cloud': 'db',
+    hana: 'db',
+    'hana-mt': 'db', // For compatibility only
+    'sql-mt': 'db', // For compatibility only
+    destinations: 'destinations',
+    connectivity: 'connectivity',
+    'audit-log': 'auditlog',
+    'audit-log-to-restv2': 'auditlog',
+    'enterprise-messaging': 'messaging',
+    'enterprise-messaging-amqp': 'messaging',
+    'enterprise-messaging-http': 'messaging',
+    'enterprise-messaging-shared': 'messaging',
+    'redis-messaging': 'messaging',
+    'multitenancy': 'multitenancy'
+}
+
+const PreferredKinds = {
+    multitenancy: 1,
+    'hana-cloud': 1,
+    xsuaa: 1,
+    'xsuaa-auth': 1,
+    'ias-auth': 1,
+    'saas-registry': 1
+}
+
+async function bind(options) {
+    let on
+    switch (options.on) {
+        case 'k8s':
+        case 'kubernetes':
+            on = 'k8s'
+            break
+        case undefined:
+        case null:
+        case 'cf':
+        case 'cloudfoundry':
+            on = 'cf'
+            break
+        default:
+            throw `invalid value '${options.on}' for option --on.`
+    }
+    const plugin = require(`./${on}`)
+
+    if (!options['to-app-services']) console.log(`retrieving data from ${bold(plugin.displayName())}...`)
+
+    const services = options.to.split(/,/g)
+    const resolvedServices = await Promise.all(services.map(async service => {
+        const binding = { on, ...plugin.binding4(service) }
+        const resolved = await _resolveBinding(binding)
+        delete resolved.credentials
+        return resolved
+    }))
+    if (options.kind) {
+        resolvedServices.forEach(service => service.kind = options.kind)
+    } else {
+        _determineKinds(resolvedServices)
+    }
+    for (const resolved of resolvedServices) {
+        const { kind, binding, binding: { instance, secret } } = resolved
+        if (options.serviceArg) {
+            resolved.name = options.serviceArg
+        } else if (kind) {
+            const requiresName = KindToRequiresNameMap[kind]
+            if (!requiresName) throw new Error(`Unknown CDS service name for service ${bold(instance)}. Please specify as argument for ${bold('cds bind')}.`)
+            resolved.name = requiresName
+        }
+        resolved.name ??= `custom-service:${instance || secret}`
+        const kindText = kind ? ` with kind ${bold(kind)}` : ''
+        console.log(`binding ${bold(resolved.name)} to ${plugin.displayName()} ${_bindingText(binding)}${kindText}`)
+    }
+    return resolvedServices
+}
+
+async function storeBindings(resolvedServices, options) {
+    const cdsrcPrivate = '.cdsrc-private.json'
+    let jsonPath = options.out || cdsrcPrivate
+    if (jsonPath === cdsrcPrivate) {
+        await git.ensureFileIsGitignored(cdsrcPrivate)
+    }
+    jsonPath = jsonPath.replace(/~/g, os.homedir())
+    if (path.extname(jsonPath) !== '.json') {
+        jsonPath = path.join(jsonPath, '.cdsrc.json')
+    }
+    const conf = exists(jsonPath) ? await read(jsonPath) : {}
+    let cdsRoot
+    if (path.basename(jsonPath) === 'package.json') {
+        conf.cds = conf.cds || {}
+        cdsRoot = conf.cds
+    } else {
+        cdsRoot = conf
+    }
+    const profile = `[${options.for}]`
+    const features = cdsRoot.features?.[profile]
+    if (features) delete features.emulate_vcap_services
+    cdsRoot.requires ??= {}
+    const section = cdsRoot.requires[profile] ??= {}
+
+    for (const { name, kind, binding, credentials } of resolvedServices) {
+        const requireService = section[name] ??= {}
+        binding.credentials = _getServiceCredentials(binding, resolvedServices, options)
+        Object.assign(requireService, { binding: { ...binding, vcap: undefined }, credentials, kind, vcap: { name } })
+    }
+    await fs.promises.mkdir(path.dirname(jsonPath), { recursive: true })
+    await fs.promises.writeFile(jsonPath, JSON.stringify(conf, null, 2))
+    await fs.promises.chmod(jsonPath, 0o600)
+    console.log(`saving bindings to ${bold(jsonPath)} in profile ${bold(options.for)}`)
+}
+
+function mergeCredentials(credentials, customCredentials) {
+    if (!customCredentials) return credentials
+    for (const key in customCredentials) {
+        if (typeof customCredentials[key] === 'object') {
+            if (credentials[key] && typeof credentials[key] !== 'object') {
+                throw `Cannot merge credentials: '${key}' is not an object`
+            }
+            if (!credentials[key]) {
+                credentials[key] = {}
+            }
+            credentials[key] = mergeCredentials(credentials[key], customCredentials[key])
+        } else {
+            credentials[key] = customCredentials[key]
+        }
+    }
+    return credentials
+}
+
+async function bindingEnv(options) {
+    const bindings = _getUnresolvedBindings(options)
+    const resolvedBindings = await _resolveBindings({ ...options, bindings, cache: {} })
+    return resolvedBindings ? { VCAP_SERVICES: _toVcapServices(resolvedBindings) } : undefined
+}
+
+async function updateBindings(options, { onBeforeUpdate, onAfterUpdate } = {}) {
+    const bindings = _getUnresolvedBindings(options)
+    if (onBeforeUpdate) await onBeforeUpdate()
+    let resolvedBindings
+    try {
+        resolvedBindings = await _resolveBindings({ ...options, bindings, cache: {} })
+    } catch (error) {
+        console.error(error.message) // REVISIT: Why not throw here?
+        return
+    }
+    const env = resolvedBindings ? { VCAP_SERVICES: _toVcapServices(resolvedBindings) } : { VCAP_SERVICES: '{}' }
+    if (onAfterUpdate) await onAfterUpdate({ bindings: resolvedBindings, env })
+    return { bindings: resolvedBindings, env }
+}
+
+module.exports = { bind, storeBindings, mergeCredentials, bindingEnv, updateBindings }
+
+/* Private helpers */
+
+function _bindingText(binding) {
+    try { return require(`./${binding.on ?? binding.type}`).description4(binding) } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') throw `unsupported binding type ${bold(binding.on ?? binding.type)}.`
+    }
+}
+
+function _resolveBinding(binding, name) {
+    try { return require(`./${binding.on ?? binding.type}`).resolve(name, binding) } catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') throw `unsupported binding type ${bold(binding.on ?? binding.type)} for service ${bold(name)}.`
+    }
+}
+
+function _determineKinds(services) {
+    const vcapServices = {}
+
+    // Build VCAP_SERVICES
+    for (const service of services) {
+        service.kindCandidates = []
+        const { vcap = {} } = service.binding || {}
+        const { label, type = label } = vcap
+        if (!type) continue
+        if (!vcapServices[type]) vcapServices[type] = []
+        vcapServices[type].push({ credentials: { dummy: 'dummy' }, ...vcap, service })
+    }
+
+     // Auto configure services based on VCAP_SERVICES
+    const cds = require('../cds')
+    const env = cds.env.for('cds', process.cwd())
+    if (!env._find_credentials_for_required_service) { // REVISIT: Proper API
+        throw new Error(`Please provide a service kind or update @sap/cds version to use the kind detection.`)
+    }
+    const requires = env.requires.kinds || {}
+    for (const [kind, service] of Object.entries(requires)) {
+        const vcapService = env._find_credentials_for_required_service(kind, service, vcapServices)
+        if (!vcapService) continue
+        const isUniqueKind = !Object.values(requires).some(otherService =>
+            otherService !== service && otherService.kind === kind
+        )
+        if (isUniqueKind) vcapService.service.kindCandidates.push(kind)
+    }
+    for (const service of services) {
+        const preferredKind = service.kindCandidates.find(kind => kind in PreferredKinds)
+        if (preferredKind) {
+            service.kind = preferredKind
+        } else if (service.kindCandidates.length === 1) {
+            service.kind = service.kindCandidates[0]
+        }
+        delete service.kindCandidates
+    }
+}
+
+function _getUnresolvedBindings({ cwd = process.cwd(), env } = {}) {
+    if (!env) {
+        env = cds.env.for('cds', path.resolve(cwd)) // REVISIT: This might load cds.env too early!
+    }
+    const bindings = {}
+    const requires = env.requires || {}
+    for (const name in requires) {
+        const service = requires[name]
+        if (service?.binding && !service.binding.resolved) {
+            bindings[name] = { ...service.binding, kind: service.kind }
+        }
+    }
+    return bindings
+}
+
+async function _resolveBindings({ bindings, cwd = process.cwd(), env, cache = {}, silent }) {
+    bindings ??= _getUnresolvedBindings({ cwd, env })
+    if (Object.keys(bindings).length === 0) return undefined
+    if (!silent) console.log(`resolving cloud service bindings...`)
+    const resolvedBindings = {}
+    await Promise.all(Object.keys(bindings).map(async name => {
+        const binding = bindings[name]
+        const cacheKey = JSON.stringify(binding)
+        let resolvedBinding
+        if (!cache[cacheKey]) {
+            resolvedBinding = cache[cacheKey] = await _resolveBinding(binding, name)
+            if (!silent) console.log(`bound ${bold(name)} to ${binding.type} ${_bindingText(binding)}`)
+        } else {
+            resolvedBinding = cache[cacheKey]
+        }
+        resolvedBindings[name] = resolvedBinding
+    }))
+    return Object.keys(resolvedBindings).length > 0 ? resolvedBindings : undefined
+}
+
+function _toVcapServices(bindings) {
+    const services = {}
+    for (const name in bindings) {
+        const { binding, credentials } = bindings[name]
+        const vcap = binding.vcap ?? {}
+        const type = vcap.type ?? vcap.label
+        services[type] ??= []
+        services[type].push({ ...vcap, name, credentials })
+    }
+    return JSON.stringify(services)
+}
+
+function _getServiceCredentials(binding, services, options) {
+    const { to, credentials } = options
+    const { type } = binding
+    if (!credentials) return
+    const plugin = require(`./${type}`)
+    const service = plugin.service4(binding, to ?? services)
+    return credentials[service] ?? credentials
+}

package/lib/build/buildTaskEngine.js

@@ -261,7 +261,7 @@ The higher the value the earlier the plugin is run.`
     }
 
     _logTimer(start, end) {
-        console.log(`build completed in ${end - start} ms\n`)
+        console.log(`build completed in ${end - start} ms`)
     }
 
     _logTaskHandler(plugin) {

package/lib/build/plugins/helm/files/subcharts/content-deployment/Chart.yaml

@@ -1,7 +1,5 @@
 apiVersion: v2
 description: A Helm Chart for creating a Content Deployment job
 name: content-deployment
-sources:
-- https://github.tools.sap/unified-runtime/content-deployment
 type: application
 version: 1.7.1

package/lib/build/plugins/helm/files/subcharts/web-application/Chart.yaml

@@ -2,7 +2,5 @@ apiVersion: v2
 description: A Helm chart for web app
 kubeVersion: '>= 1.21'
 name: web-application
-sources:
-- https://github.tools.sap/unified-runtime/web-application
 type: application
-version: 1.22.0
+version: 1.23.0

package/lib/build/plugins/helm/files/subcharts/web-application/templates/service-binding.yaml

@@ -33,5 +33,8 @@ spec:
   {{- if $mergedParams.credentialsRotationPolicy }}
   credentialsRotationPolicy: {{ $mergedParams.credentialsRotationPolicy | toYaml | nindent 4 }}
   {{- end }}
+  {{- if $mergedParams.secretTemplate }}
+  secretTemplate: {{ $mergedParams.secretTemplate | toYaml | nindent 2}}
+  {{- end }}
 {{- end }}
 {{- end }}

package/lib/build/plugins/helm/files/subcharts/web-application/values.schema.json

@@ -793,6 +793,9 @@
                                 "secretName": {
                                     "type": "string"
                                 },
+                                "secretTemplate": {
+                                    "type": "string"
+                                },
                                 "secretKey": {
                                     "type": "string",
                                     "default": "credentials"

package/lib/build/plugins/helm/files/subcharts/web-application/values.yaml

@@ -14,7 +14,7 @@ global:
     _internal:
       web-application:
         versions:
-          1.22.0: true
+          1.23.0: true
 ## Will be used instead of the `.Chart.Name`, e.g. when generating the Deployment name.
 # nameOverride: name
 
@@ -258,6 +258,7 @@ bindings:
 #       enabled: false
 #   hana:
 #     serviceInstanceName: hana-manual
+#     secretTemplate: -> see https://github.com/SAP/sap-btp-service-operator?tab=readme-ov-file#custom-formats
 #   portal:
 #     fromSecret: manual-secret # user-provided-service
 

package/lib/build/util.js

@@ -134,7 +134,7 @@ async function getDefaultModelOptions(ws = false, filter) {
             workspaces.forEach(workspace => {
                 cds.root = path.join(root, workspace)
                 cds.env = cds.env.for('cds', cds.root)
-                paths = paths.concat(_filterModelPaths(cds.resolve(cds.env.requires.toggles ? wildcards : '*', false), filter).map(p => path.join(workspace, p)))
+                paths = paths.concat(_filterModelPaths(cds.resolve(cds.env.requires.toggles ? wildcards : '*', false), filter).map(p => normalizePath(path.join(workspace, p))))
             })
         } finally {
             cds.root = root

package/lib/compile/to-mermaid.js

@@ -114,7 +114,7 @@ module.exports = function to_mermaid (model, options={}) {
 }
 
 function resolveTargets (query) {
-  if (query.target)  return [ query.target.name ] // simple query, like projection on
+  if (query._target)  return [ query._target.name ] // simple query, like projection on
 
   // SELECT: { from: { args: [{ ref: ['t1'] }, { ref: ['t2'] }], join: ..., on: ... } }
   const targets = query.SELECT?.from?.args?.filter(arg => arg.ref?.length).map (arg => arg.ref[0])
@@ -205,4 +205,3 @@ function to_mta_mermaid (file) {
 
   return diag
 }
-

package/lib/deploy/to-hana/hana.js

@@ -14,7 +14,7 @@ const mtaUtil = require('./mtaUtil');
 
 const { bold, info, warn } = require('../../util/term');
 
-const { bind, storeBindings } = require('../../bind');
+const { bind, storeBindings } = require('../../bind/shared');
 const { BUILD_TASK_HANA, OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, OUTPUT_MODE_RESULT } = require('../../build/constants');
 
 const DEBUG = cds.debug('cli');

package/lib/deploy/to-hana/mtaUtil.js

@@ -24,18 +24,6 @@ async function getHanaDbModuleDescriptor(projectPath, moduleName) {
     }
 }
 
-async function getServiceModuleDescriptor(projectPath, moduleName, moduleType) {
-    // mta might be null if mta.yaml does not exist
-    const mta = await _getMta(projectPath)
-    const projectInfo = await _getProjectInfo(projectPath, mta)
-    const appName = _getApplicationName(mta, moduleName, moduleType)
-
-    return {
-        project: projectInfo,
-        appName: appName ? appName : `${projectInfo.name}-${moduleName}`
-    }
-}
-
 async function _getProjectInfo(projectPath, mta) {
     const details = {
     }
@@ -166,6 +154,5 @@ function _findHdiResource(mta, moduleName) {
 
 module.exports = {
     getHanaDbModuleDescriptor,
-    getServiceModuleDescriptor,
     MTA_YAML
 }

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

@@ -139,12 +139,12 @@ module.exports = {
                         as: {
                             type: "string",
                             description: "Converts the input file into one of these supported formats: cds, csn or json.",
-                            $ref: "#/$defs/import-options/as"
+                            $ref: "#/$defs/importOptions/as"
                         },
                         from: {
                             type: "string",
                             description: "Imports the model from the one of the given options: edmx, openapi or asyncapi.",
-                            $ref: "#/$defs/import-options/from"
+                            $ref: "#/$defs/importOptions/from"
                         },
                         force: {
                             type: "boolean",
@@ -173,7 +173,7 @@ module.exports = {
                         }
                     }
                 },
-                
+
                 export: {
                     type: "object",
                     description: "Customize cds compile settings",
@@ -191,7 +191,7 @@ module.exports = {
                                 merged: {
                                     type: "object",
                                     description: "properties that needs to be there when merged option is used",
-                                    additionalProperties: false, 
+                                    additionalProperties: false,
                                     properties: {
                                         title: {
                                             type: "string",
@@ -224,37 +224,24 @@ module.exports = {
                                     type: "object",
                                     description: "Parameters related to the source of event",
                                     default: {
+                                        region: "the region",
+                                        applicationNamespace: "the namespace",
+                                        instanceId: "the instance id"
+                                    },
+                                    additionalProperties: false,
+                                    properties: {
                                         region: {
-                                        "description": "The regional context of the application.",
-                                        "schema": {
-                                            "type": "string"
-                                        }
+                                            type: "string",
+                                            description: "The regional context of the application"
                                         },
                                         applicationNamespace: {
-                                        "description": "The registered namespace of the application.",
-                                        "schema": {
-                                            "type": "string"
-                                        }
+                                            type: "string",
+                                            description: "The registered namespace of the application"
                                         },
                                         instanceId: {
-                                        "description": "The instance id (tenant, installation, ...) of the application.",
-                                        "schema": {
-                                            "type": "string"
-                                        }
+                                            type: "string",
+                                            description: "The instance id (tenant, installation, ...) of the application."
                                         }
-                                    },
-                                    additionalProperties: false,
-                                    region: {
-                                        type: "string",
-                                        description: "The regional context of the application"
-                                    },
-                                    applicationNamespace: {
-                                        type: "string",
-                                        description: "The registered namespace of the application"
-                                    },
-                                    instanceId: {
-                                        type: "string",
-                                        description: "The instance id (tenant, installation, ...) of the application."
                                     }
                                 },
                                 event_characteristics: {
@@ -332,7 +319,7 @@ module.exports = {
             ]
         },
 
-        import_options: {
+        importOptions: {
             from: {
                 oneOf: [
                     {

package/lib/import/common.js

@@ -141,11 +141,22 @@ async function isValidInputFile(inputFileLoc) {
 }
 
 async function _copyToSrvExternal(file, dst, cwd) {
-    const dstDir = path.dirname(dst), srcDir = path.dirname(file);
+    const dstDir = path.dirname(dst), srcDir = path.resolve(path.dirname(file));
     if (!file.startsWith(dstDir + path.sep)) {
         await mkdirp(dstDir);
-        const copyOrMove = srcDir === cwd || srcDir == process.cwd() ? fs.renameSync : fs.copyFileSync;
-        await copyOrMove(file, dst);
+        const copyOrMove = srcDir === cwd || srcDir === process.cwd() ? fs.renameSync : fs.copyFileSync;
+        try {
+            copyOrMove(file, dst);
+        } catch (err) {
+            // cross-device link error (might happen in docker containers), fall back to copy and delete
+            // see cap/issues#18004
+            if (err.code === 'EXDEV') {
+                fs.copyFileSync(file, dst);
+                fs.unlinkSync(file);
+            } else {
+                throw err;
+            }
+        }
         return dst;
     }
     return file;
@@ -194,25 +205,24 @@ function _getServiceNames(csn) {
 }
 
 function _validateAndComputeOutputFilePath(outputFileLoc, as, destFilePath) {
-    let index, extension, expectedExtension, supportedExtension;
+    let extension, expectedExtension, supportedExtension;
     if (typeof (outputFileLoc) !== 'boolean') {
-        index = outputFileLoc.lastIndexOf(".");
-        extension = outputFileLoc.substring(index + 1);
+        extension = path.extname(outputFileLoc).substring(1);
         expectedExtension = (as) ? _getSuffix(as) : "csn";
-        supportedExtension = (index > 0) ? _supportedAsFormats().includes(extension) : false;
+        supportedExtension = extension ? _supportedAsFormats().includes(extension) : false;
     }
 
     if (outputFileLoc === true || // if output file is not mentioned
         outputFileLoc[0] === "-" || // if output file is missing and "--as" is considered as output file
         outputFileLoc.trim() === "") {
         throw new Error(messages.SPECIFY_OUTPUT_FILE);
-    } else if (index > 0 && !supportedExtension) {
+    } else if (extension && !supportedExtension) {
         // extension not supported, eg., "test.abs", "./sv/external.test.abcs", "./a."
         throw new Error(messages.INVALID_OUTPUT_FILE);
-    } else if (index > 0 && !as && extension != "json" && extension != "csn") {
+    } else if (extension && !as && extension != "json" && extension != "csn") {
         // --as option is not provided but output file is like: "test.cds", "./srv/external/test.cds"
         throw new Error(messages.INCORRECT_EXTENSION);
-    } else if (index > 0 && as && extension != expectedExtension) {
+    } else if (extension && as && extension != expectedExtension) {
         // extension not supported by --as option, e.g., "cds import <file> --out test.yml --as cds"
         throw new Error(messages.OUTPUT_FILE_MISMATCH);
     } else if (supportedExtension || (!outputFileLoc.endsWith("\\") && !outputFileLoc.endsWith("/"))) {

package/lib/init/constants.js

@@ -5,7 +5,7 @@ module.exports = {
     COMMAND_ADD: 'add',
 
     JAVA_LTS_VERSIONS: [17, 21],
-    MAVEN_ARCHETYPE_VERSION: '3.7.2',
+    MAVEN_ARCHETYPE_VERSION: '3.8.0',
 
     OPTIONS: Object.freeze({
         COMPLETION: 'completion',

package/lib/init/merge.js

@@ -129,12 +129,17 @@ async function _mergeJSON(into, from, project, semantics) {
  * @throws {Error} Throws an error if empty target YAML is passed in
  */
 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)
+    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)
 
     if (!target?.contents) {
         if (typeof into === 'string' && typeof from === 'string') {
-            project ? await writeYAML(into, source) : await copy(from, into)
+            if (project) await writeYAML(into, source)
+            else await copy(from, into)
             return source
         }
         throw new Error(`Target YAML doesn't exist`)
@@ -143,19 +148,19 @@ async function _mergeYAML(into, from, project, semantics = {}) {
     const entryMap = new Map, templateEntryMap = new Map
 
     const { additions, overwrites, deletions, relationships } = semantics
-    additions?.forEach(entry => {
+    for (const entry of additions ?? []) {
         entryMap.set(entry, undefined)
         templateEntryMap.set(entry, undefined)
-    })
-    deletions?.forEach(deletion => {
+    }
+    for (const deletion of deletions ?? []) {
         entryMap.set(deletion.item, undefined)
-    })
-    relationships?.forEach(relationship => {
+    }
+    for (const relationship of relationships ?? []) {
         const [entry] = relationship.into
         const [insertEntry] = relationship.insert
         const hash = JSON.stringify(insertEntry) + ' -> ' + JSON.stringify(entry)
         entryMap.set(hash, undefined)
-    })
+    }
 
     let collectionStack = [target.contents]
 
@@ -347,32 +352,36 @@ async function _mergeYAML(into, from, project, semantics = {}) {
     // 7. Create missing relationships
     _traverseYAMLNode(target.contents, null, {
         mergeCollection: (targetNode, templateNode) => {
-            if (YAML.isSeq(templateNode)) {
-                const targetJSON = YAML.parse(String(targetNode))
-                const relationship = semantics.relationships?.filter(r => r)
-                    .find(relationship => {
-                        const [entry, keyPath] = relationship.into
-                        if (!entryMap.get(entry)) return false
-                        const existingNode = _getYAMLProperty(entryMap.get(entry).node, keyPath)
-                        return targetNode === existingNode
-                })
-                if (!relationship) return
-
-                const intoKey = relationship.into[relationship.into.length - 1]
-                const [entry, entryKeyPath] = relationship.insert
-                const missingPairs = [entry]
-                    .filter(item =>
-                        !targetJSON.some(targetItem =>
-                            _getProperty(entryMap.get(item).json, entryKeyPath) === targetItem[intoKey]
-                        )
-                    )
-                    .map(item => entryMap.get(item).node.get(intoKey))
-                missingPairs.forEach(pair => {
-                    targetNode.add({ [intoKey]: pair })
+          if (YAML.isSeq(templateNode)) {
+            const targetJSON = YAML.parse(String(targetNode))
+            const relationships = semantics.relationships?.filter(relationship => {
+              const [entry, keyPath] = relationship.into
+              if (!entryMap.get(entry)) return false
+              const existingNode = _getYAMLProperty(entryMap.get(entry).node, keyPath)
+              return targetNode === existingNode
+            }) ?? []
+
+            for (const { into, insert } of relationships) {
+              const intoKey = into[into.length - 1]
+              const [insEntry, entryKeyPath] = insert
+              const missingPairs = [insEntry]
+                .filter(item => {
+                  if (!entryMap.get(item)) {
+                    const spec = inspect(item, { colors, depth:11 })
+                    throw new Error(`Did not find entry in template for ${spec} in ${from}:\n${source}`)
+                  }
+                  return !targetJSON.some(targetItem =>
+                    _getProperty(entryMap.get(item).json, entryKeyPath) === targetItem[intoKey]
+                 )
                 })
+                .map(item => entryMap.get(item).node.get(intoKey))
+              for (const pair of missingPairs) {
+                targetNode.add({ [intoKey]: pair })
+              }
             }
+          }
         }
-    }, source.contents)
+      }, source.contents)
 
     typeof into === 'string' && await writeYAML(into, target)
     return target