sf-plugin-cms 0.4.0 → 0.6.0

package/lib/services/import-workspace.js

@@ -3,11 +3,15 @@ import { lstat, mkdir, open, readFile, readdir, realpath } from 'node:fs/promise
 import path from 'node:path';
 import { cleanupOwnedPath, replaceFileByAtomicRename, } from './atomic-publish.js';
 import { CmsRequestError } from '../transport/json-request.js';
-import { assertWorkspaceExportManifest, } from '../contracts/workspace-export.js';
+import { assertWorkspaceExportManifest, UnsupportedWorkspacePackageVersionError, } from '../contracts/workspace-export.js';
 import { getContent } from './read.js';
 import { variantIdentity } from './variant-identity.js';
 import { inventoryExportReferences } from './export-references.js';
-import { planImportIdentities, planNativeCopies } from './import-identities.js';
+import { planImportIdentities, planNativeCopies, } from './import-identities.js';
+import { planEmailFragmentCopies } from './email-fragment.js';
+import { planWebFragmentCopies, validateDataGraphPrerequisites, } from './web-fragment.js';
+import { planLandingPageTemplateCopies, validateLandingPageTemplatePrerequisites, } from './landing-page-template.js';
+import { planLandingPageCopies, resolveLandingPageTemplateDependencies, validateLandingPagePrerequisites, } from './landing-page.js';
 import { loadEditableRawHtml } from './editable-raw-html-import.js';
 import { isDeepStrictEqual } from 'node:util';
 import { createContent, createVariant, } from './write.js';
@@ -233,6 +237,9 @@ export async function loadWorkspaceExport(sourceDirectory, options = {}) {
     const manifestValue = parseJson(manifestBytes, 'manifest.json');
     assertWorkspaceExportManifest(manifestValue);
     const manifest = manifestValue;
+    if (options.profile === 'image' && manifest.schemaVersion !== 2) {
+        throw new UnsupportedWorkspacePackageVersionError('Image import profile requires workspace package manifest version 2');
+    }
     const packageFiles = await enumeratePackageFiles(canonicalSource, canonicalSource);
     const expectedFiles = [
         'manifest.json',
@@ -242,6 +249,19 @@ export async function loadWorkspaceExport(sourceDirectory, options = {}) {
         throw new TypeError('Workspace package contains missing, substituted, or unlisted regular files');
     }
     const manifestItems = new Map(manifest.items.map((item_) => [item_.path, item_]));
+    for (const [index, declared] of manifest.items.entries()) {
+        const segments = declared.path.split('/');
+        const file = path.join(canonicalSource, ...segments);
+        const normalized = path.normalize(file);
+        if (!normalized.startsWith(`${canonicalSource}${path.sep}`)) {
+            throw new TypeError(`manifest.items[${index}].path escapes the source directory`);
+        }
+        const bytes = await readStableRegularFile(file, `Manifest item ${declared.path}`);
+        const actualSha256 = createHash('sha256').update(bytes).digest('hex');
+        if (actualSha256 !== declared.sha256) {
+            throw new TypeError(`Manifest item ${declared.path} failed SHA-256 verification`);
+        }
+    }
     const seenFiles = new Set();
     const seenIds = new Set();
     const items = [];
@@ -414,7 +434,13 @@ function variantPayload(item, contentKey) {
     return payload;
 }
 function isProvenNotFound(error) {
-    return (error instanceof CmsRequestError && error.operationKey === 'content.get' && error.status === 404);
+    return (error instanceof CmsRequestError &&
+        error.operationKey === 'content.get' &&
+        (error.status === 404 ||
+            ((error.status === 400 || error.status === undefined) &&
+                error.errorEntryCount === 1 &&
+                error.errorCode === 'INVALID_ID_FIELD' &&
+                error.responseMessage === 'Provide a valid content key, ID, or FQN.')));
 }
 function assertTransportableBody(value) {
     if (Array.isArray(value)) {
@@ -432,6 +458,16 @@ function assertTransportableBody(value) {
     for (const child of Object.values(value))
         assertTransportableBody(child);
 }
+function selectedLandingPageTemplateReferences(source, selectedItems, resolvableRelationshipIds) {
+    const selectedIds = new Set(selectedItems.map(({ id }) => id));
+    return source.manifest.externalReferences.filter((reference) => {
+        if (reference.kind !== 'cms.relationship' || !selectedIds.has(reference.source.sourceId)) {
+            return true;
+        }
+        return (resolvableRelationshipIds !== undefined &&
+            !resolvableRelationshipIds.has(reference.referenceId));
+    });
+}
 function selectedNativeReferences(source, selectedItems) {
     const selectedIds = new Set(selectedItems.map(({ id }) => id));
     const inventory = inventoryExportReferences(source.manifest.workspaceId, 
@@ -452,7 +488,7 @@ function selectedNativeReferences(source, selectedItems) {
             source.manifest.items.some((item) => item.referenceId === reference.referenceId && item.path !== ownerEntry.file));
     });
 }
-function preflightReferences(plan, references = plan.source.manifest.externalReferences) {
+function preflightReferences(plan, references = plan.source.manifest.externalReferences, allowValidatedStructuredReferences = false) {
     if (references.some((reference) => reference.required && reference.resolution !== 'included') ||
         plan.source.manifest.dependencies.length > 0) {
         throw new TypeError('Unresolved required package reference; import is blocked');
@@ -469,7 +505,8 @@ function preflightReferences(plan, references = plan.source.manifest.externalRef
                 item.contentType === 'sfdc_cms__doc') {
                 throw new TypeError('Unresolved content reference or media transport; import is blocked');
             }
-            assertTransportableBody(item.contentBody);
+            if (!allowValidatedStructuredReferences)
+                assertTransportableBody(item.contentBody);
             if (item.externalSource !== undefined)
                 assertTransportableBody(item.externalSource);
             const bodyUrl = item.contentBody['sfdc_cms:urlName'];
@@ -499,10 +536,24 @@ async function preflightConflicts(connection, plan, requestOptions) {
         }
     }
 }
+function soqlString(value) {
+    return `'${value.replaceAll('\\', '\\\\').replaceAll("'", String.raw `\'`)}'`;
+}
+async function preflightApiNames(connection, plan) {
+    if (connection.query === undefined) {
+        throw new TypeError('Destination API-name absence cannot be proven; email-fragment apply is blocked');
+    }
+    for (const apiName of new Set(plan.groups.flatMap(({ primary, variants }) => [primary, ...variants].flatMap((item) => (item.apiName === undefined ? [] : [item.apiName]))))) {
+        const result = await connection.query(`SELECT ApiName FROM ManagedContent WHERE ApiName = ${soqlString(apiName)} LIMIT 1`);
+        if (result.totalSize !== 0 || result.records.length > 0) {
+            throw new Error(`API name ${apiName} already exists`);
+        }
+    }
+}
 function compareMappingIdentity(left, right) {
     return `${left.kind}\u0000${left.referenceId}`.localeCompare(`${right.kind}\u0000${right.referenceId}`);
 }
-function importContractResult(source, destinationOrgId, plan, mappings, references) {
+function importContractResult(source, destinationOrgId, plan, mappings, references, templatePrerequisites) {
     return {
         sourcePackage: {
             manifestSha256: source.manifestSha256,
@@ -515,11 +566,66 @@ function importContractResult(source, destinationOrgId, plan, mappings, referenc
         integrity: source.integrity,
         mappings: mappings.toSorted(compareMappingIdentity),
         references: references.toSorted(compareMappingIdentity),
+        ...(templatePrerequisites === undefined ? {} : { templatePrerequisites }),
     };
 }
 function jsonBytes(value) {
     return `${JSON.stringify(value, null, 2)}\n`;
 }
+function sha256Json(value) {
+    return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+function landingPagePhaseEvidence(proposal, item) {
+    const dependencyIndex = proposal.compatibility.findIndex(({ pageVariantId }) => pageVariantId === item.id);
+    const dependency = proposal.templateDependencies[dependencyIndex];
+    if (dependency?.validationStatus !== 'passed' || dependency.target === undefined) {
+        throw new TypeError('Landing-page target template validation evidence is incomplete');
+    }
+    return {
+        checkedAt: new Date().toISOString(),
+        status: 'passed',
+        template: structuredClone(dependency.target),
+        imageResolutionSha256: sha256Json(proposal.cmsPrerequisites),
+        dataGraphResolutionSha256: sha256Json(proposal.dataGraphs),
+        targetPageIdentitySha256: sha256Json({
+            apiName: item.apiName,
+            contentKey: item.contentKey,
+            contentType: item.contentType,
+            title: item.title,
+            urlName: item.urlName,
+        }),
+    };
+}
+function landingPageTemplateEvidence(source, proposal) {
+    return proposal.items.map((item, index) => {
+        const compatibility = proposal.compatibility[index];
+        const dependency = proposal.templateDependencies[index];
+        const pair = source.manifest.landingPageTemplatePairs?.find(({ page }) => page.variantId === compatibility.pageVariantId);
+        if (pair === undefined)
+            throw new TypeError('Landing-page template pair evidence is missing');
+        return {
+            sourcePage: pair.page,
+            sourceTemplate: pair.template,
+            requestedTargetSelector: {
+                ...(dependency.targetContentKey === undefined
+                    ? {}
+                    : { contentKey: dependency.targetContentKey }),
+                ...(dependency.targetApiName === undefined ? {} : { apiName: dependency.targetApiName }),
+                ...(dependency.targetTitle === undefined ? {} : { title: dependency.targetTitle }),
+            },
+            relationship: {
+                referenceId: compatibility.relationshipReferenceId,
+                descriptorSha256: compatibility.relationshipDescriptorSha256,
+            },
+            normalization: {
+                version: compatibility.normalizationVersion,
+                pageBodySha256: compatibility.normalizedPageBodySha256,
+                templateBodySha256: compatibility.normalizedTemplateBodySha256,
+            },
+            preflight: landingPagePhaseEvidence(proposal, item),
+        };
+    });
+}
 async function writeExclusive(file, value) {
     const handle = await open(file, 'wx');
     try {
@@ -675,15 +781,43 @@ export async function executeWorkspaceImport(options) {
     }
     validateRelationships(source.items);
     const native = options.nativeCopyMappings !== undefined;
-    if (native && options.identityMappings !== undefined)
+    const emailFragment = options.emailFragmentMappings !== undefined;
+    const webFragment = options.webFragmentMappings !== undefined;
+    const landingPageTemplate = options.landingPageTemplateMappings !== undefined;
+    const landingPage = options.landingPageMappings !== undefined;
+    if (Number(native) +
+        Number(emailFragment) +
+        Number(webFragment) +
+        Number(landingPageTemplate) +
+        Number(landingPage) +
+        Number(options.identityMappings !== undefined) >
+        1)
         throw new TypeError('Choose one identity profile');
     if (options.editableDirectory !== undefined && !native)
         throw new TypeError('editableDirectory requires nativeCopyMappings');
     let proposal;
     let editableSource;
+    let landingPageTemplateProposal;
+    let landingPageProposal;
+    let webFragmentProposal;
     if (native) {
         ({ proposal, editableSource } = await planNativeWorkspaceImport(source, options.nativeCopyMappings, options.editableDirectory));
     }
+    else if (emailFragment) {
+        proposal = planEmailFragmentCopies(source, options.emailFragmentMappings);
+    }
+    else if (webFragment) {
+        webFragmentProposal = planWebFragmentCopies(source, options.webFragmentMappings);
+        proposal = webFragmentProposal;
+    }
+    else if (landingPageTemplate) {
+        landingPageTemplateProposal = planLandingPageTemplateCopies(source, options.landingPageTemplateMappings);
+        proposal = landingPageTemplateProposal;
+    }
+    else if (landingPage) {
+        landingPageProposal = planLandingPageCopies(source, options.landingPageMappings);
+        proposal = landingPageProposal;
+    }
     else if (options.identityMappings !== undefined)
         proposal = planImportIdentities(source, options.identityMappings);
     const selectedIds = new Set(proposal?.items.map((item) => item.id));
@@ -696,7 +830,9 @@ export async function executeWorkspaceImport(options) {
                 retryable: false,
             },
         ];
-    const selectedSource = native ? { ...source, items: proposal.items } : source;
+    const selectedSource = native || emailFragment || webFragment || landingPageTemplate || landingPage
+        ? { ...source, items: proposal.items }
+        : source;
     const sourcePlan = planWorkspaceImport(selectedSource, options.destinationWorkspace, options.workspaceId);
     // Keep original variant IDs and source manifest associations; never substitute the raw package.
     const proposedById = new Map(proposal?.items.map((item) => [item.id, item]));
@@ -711,23 +847,56 @@ export async function executeWorkspaceImport(options) {
                 variants: group.variants.map((variant) => proposedById.get(variant.id)),
             })),
         };
-    preflightReferences(plan, native ? selectedNativeReferences(source, proposal.items) : undefined);
+    let selectedReferences;
+    if (native)
+        selectedReferences = selectedNativeReferences(source, proposal.items);
+    else if (landingPageTemplate) {
+        selectedReferences = selectedLandingPageTemplateReferences(source, proposal.items);
+    }
+    else if (landingPage) {
+        selectedReferences = selectedLandingPageTemplateReferences(source, proposal.items, new Set(landingPageProposal.compatibility.map(({ relationshipReferenceId }) => relationshipReferenceId)));
+    }
+    preflightReferences(plan, selectedReferences, landingPageTemplate || landingPage);
     const requestOptions = options.requestOptions ?? {};
     if (!native)
         await preflightConflicts(options.connection, plan, requestOptions);
+    if (emailFragment || webFragment || landingPageTemplate || landingPage)
+        await preflightApiNames(options.connection, plan);
+    if (webFragment) {
+        await validateDataGraphPrerequisites(options.connection, webFragmentProposal.dataGraphs);
+    }
+    if (landingPageTemplate) {
+        await validateLandingPageTemplatePrerequisites(options.connection, plan.destinationWorkspaceId, landingPageTemplateProposal, requestOptions);
+    }
+    let templatePrerequisites;
+    if (landingPage) {
+        await resolveLandingPageTemplateDependencies(options.connection, plan.destinationWorkspaceId, landingPageProposal, requestOptions);
+        await validateLandingPagePrerequisites(options.connection, plan.destinationWorkspaceId, landingPageProposal, requestOptions);
+        templatePrerequisites = landingPageTemplateEvidence(source, landingPageProposal);
+    }
     const hasNamedIdentities = plan.groups.some((group) => [group.primary, ...group.variants].some((item) => item.apiName !== undefined ||
         item.urlName !== undefined ||
         item.contentBody['sfdc_cms:urlName'] !== undefined));
-    if (!native && hasNamedIdentities && options.dryRun !== true) {
+    if (!native &&
+        !emailFragment &&
+        !webFragment &&
+        !landingPageTemplate &&
+        !landingPage &&
+        hasNamedIdentities &&
+        options.dryRun !== true) {
         throw new TypeError('Destination API-name/URL-name uniqueness cannot be verified by the supported CMS APIs; import is blocked');
     }
+    const pairedRelationshipIds = new Set(landingPageProposal?.compatibility.map(({ relationshipReferenceId }) => relationshipReferenceId));
     const references = source.manifest.externalReferences
         .filter(({ resolution }) => resolution !== 'included')
-        .map(({ kind, referenceId, resolution }) => ({
-        referenceId,
-        kind,
-        status: resolution === 'unsupported' ? 'unsupported' : 'unresolved',
-    }))
+        .map(({ kind, referenceId, resolution }) => {
+        let status = 'unresolved';
+        if (pairedRelationshipIds.has(referenceId))
+            status = 'resolved';
+        else if (resolution === 'unsupported')
+            status = 'unsupported';
+        return { referenceId, kind, status };
+    })
         .toSorted(compareMappingIdentity);
     if (options.dryRun === true) {
         const diagnostics = [
@@ -748,15 +917,18 @@ export async function executeWorkspaceImport(options) {
         if (hasNamedIdentities && !native) {
             diagnostics.unshift({
                 code: 'NAME_AVAILABILITY_UNVERIFIED',
-                message: 'Destination API-name/URL-name availability is unverified; named apply remains blocked until collision evidence is available.',
+                message: emailFragment || webFragment || landingPageTemplate || landingPage
+                    ? `Destination API-name absence was proven by exact ManagedContent.ApiName equality lookup;${webFragment || landingPageTemplate || landingPage ? ' every named prerequisite was proven in exact type/workspace scope;' : ''} other server conflict behavior remains unverified.`
+                    : 'Destination API-name/URL-name availability is unverified; named apply remains blocked until collision evidence is available.',
                 retryable: false,
             });
         }
         return {
             diagnostics,
-            contractResult: importContractResult(source, options.destinationOrgId, plan, [], references),
+            contractResult: importContractResult(source, options.destinationOrgId, plan, [], references, templatePrerequisites),
             dryRun: true,
             plan,
+            ...(templatePrerequisites === undefined ? {} : { templatePrerequisites }),
         };
     }
     if (!nonemptyString(options.reportDirectory)) {
@@ -767,10 +939,27 @@ export async function executeWorkspaceImport(options) {
     const reportFile = path.join(reportDirectory, 'workspace-import-run.json');
     const report = {
         ...(editableSource === undefined ? {} : { editableSource }),
+        ...(landingPageTemplateProposal === undefined && landingPageProposal === undefined
+            ? {}
+            : {
+                cmsPrerequisites: landingPageTemplateProposal?.cmsPrerequisites ?? landingPageProposal.cmsPrerequisites,
+            }),
+        ...(webFragmentProposal === undefined &&
+            landingPageTemplateProposal === undefined &&
+            landingPageProposal === undefined
+            ? {}
+            : {
+                dataGraphPrerequisites: webFragmentProposal?.dataGraphs ??
+                    landingPageTemplateProposal?.dataGraphs ??
+                    landingPageProposal.dataGraphs,
+            }),
         createdParents: [],
         destinationOrgId: options.destinationOrgId,
         destinationWorkspaceId: plan.destinationWorkspaceId,
         operations: [],
+        ...(templatePrerequisites === undefined
+            ? {}
+            : { templatePrerequisites: structuredClone(templatePrerequisites) }),
         runId: randomUUID(),
         sourceDirectory: source.sourceDirectory,
         sourceManifestSha256: source.manifestSha256,
@@ -808,8 +997,14 @@ export async function executeWorkspaceImport(options) {
     await writeExclusive(reportFile, report);
     try {
         for (const group of plan.groups) {
+            if (landingPageTemplate) {
+                await validateLandingPageTemplatePrerequisites(options.connection, plan.destinationWorkspaceId, landingPageTemplateProposal, requestOptions);
+            }
+            const finalPrimary = proposal?.items.find((item) => item.id === group.primary.id) ?? group.primary;
+            const finalVariants = group.variants.map((variant) => proposal?.items.find((item) => item.id === variant.id) ?? variant);
+            const finalGroup = { ...group, primary: finalPrimary, variants: finalVariants };
             const groupReferenceKeys = new Set();
-            for (const item_ of [group.primary, ...group.variants]) {
+            for (const item_ of [finalGroup.primary, ...finalGroup.variants]) {
                 for (const key of cmsContentBodyReferenceKeys(item_.contentBody, sourceReferenceValues)) {
                     groupReferenceKeys.add(key);
                 }
@@ -826,11 +1021,11 @@ export async function executeWorkspaceImport(options) {
                 }
             }
             const rewrittenGroup = hasUnknownRequiredMapping
-                ? group
+                ? finalGroup
                 : {
-                    ...group,
-                    primary: rewriteItem(group.primary, replacements),
-                    variants: group.variants.map((variant) => rewriteItem(variant, replacements)),
+                    ...finalGroup,
+                    primary: rewriteItem(finalGroup.primary, replacements),
+                    variants: finalGroup.variants.map((variant) => rewriteItem(variant, replacements)),
                 };
             const parentPayload = createPayload(rewrittenGroup, native ? plan.destinationWorkspaceId : plan.rootFolderId);
             if (native) {
@@ -838,18 +1033,60 @@ export async function executeWorkspaceImport(options) {
                 delete parentPayload.externalId;
                 delete parentPayload.externalSource;
             }
+            if (emailFragment || webFragment || landingPageTemplate || landingPage) {
+                const currentPlan = {
+                    ...plan,
+                    groups: [rewrittenGroup],
+                };
+                await preflightConflicts(options.connection, currentPlan, requestOptions);
+                await preflightApiNames(options.connection, currentPlan);
+                if (webFragment) {
+                    await validateDataGraphPrerequisites(options.connection, webFragmentProposal.dataGraphs);
+                }
+            }
+            let finalPayload = parentPayload;
+            if (landingPage) {
+                const freshProposal = planLandingPageCopies(source, options.landingPageMappings);
+                await resolveLandingPageTemplateDependencies(options.connection, plan.destinationWorkspaceId, freshProposal, requestOptions);
+                await validateLandingPagePrerequisites(options.connection, plan.destinationWorkspaceId, freshProposal, requestOptions);
+                const freshItem = freshProposal.items.find(({ id }) => id === group.primary.id);
+                if (freshItem === undefined)
+                    throw new TypeError('Landing-page pre-create item is missing');
+                const evidenceIndex = report.templatePrerequisites?.findIndex(({ sourcePage }) => sourcePage.variantId === group.primary.id);
+                if (evidenceIndex === undefined || evidenceIndex < 0) {
+                    throw new TypeError('Landing-page durable template evidence is missing');
+                }
+                const preflight = report.templatePrerequisites[evidenceIndex].preflight;
+                const preCreate = landingPagePhaseEvidence(freshProposal, freshItem);
+                if (!isDeepStrictEqual(preflight.template, preCreate.template) ||
+                    preflight.imageResolutionSha256 !== preCreate.imageResolutionSha256 ||
+                    preflight.dataGraphResolutionSha256 !== preCreate.dataGraphResolutionSha256 ||
+                    preflight.targetPageIdentitySha256 !== preCreate.targetPageIdentitySha256) {
+                    throw new TypeError('Landing-page template, image, Data Graph, or target page identity drifted before CREATE');
+                }
+                report.templatePrerequisites[evidenceIndex].preCreate = preCreate;
+                finalPayload = createPayload({ ...group, primary: freshItem, variants: [] }, plan.rootFolderId);
+            }
             const parentOperation = editableSource === undefined
-                ? pendingOperation(report, 'create-parent', group.contentKey, group.primary.language, parentPayload)
+                ? pendingOperation(report, 'create-parent', group.contentKey, group.primary.language, finalPayload)
                 : report.operations.find((operation) => operation.contentKey === group.contentKey);
             if (editableSource === undefined)
                 report.operations.push(parentOperation);
+            if (landingPage && report.templatePrerequisites !== undefined) {
+                const evidence = report.templatePrerequisites.find(({ sourcePage }) => sourcePage.variantId === group.primary.id);
+                if (evidence === undefined)
+                    throw new TypeError('Landing-page journal evidence is missing');
+                evidence.finalRequestSha256 = createHash('sha256')
+                    .update(JSON.stringify(finalPayload))
+                    .digest('hex');
+            }
             else if (parentOperation.requestSha256 !==
-                operationIdentity(report.runId, 'create-parent', group.contentKey, group.primary.language, parentPayload).requestSha256)
+                operationIdentity(report.runId, 'create-parent', group.contentKey, group.primary.language, finalPayload).requestSha256)
                 throw new TypeError('Editable CREATE payload changed after initial journal');
             await rewrite(reportFile, report);
             let parentResponse;
             try {
-                parentResponse = await createContent(options.connection, parentPayload, requestOptions);
+                parentResponse = await createContent(options.connection, finalPayload, requestOptions);
             }
             catch (error) {
                 parentOperation.state = native ? 'pending' : 'failed';
@@ -887,6 +1124,17 @@ export async function executeWorkspaceImport(options) {
                 contentKey: created.contentKey,
                 primaryVariantId: created.primaryVariantId,
             };
+            if (landingPage && report.templatePrerequisites !== undefined) {
+                const evidence = report.templatePrerequisites.find(({ sourcePage }) => sourcePage.variantId === group.primary.id);
+                if (evidence === undefined)
+                    throw new TypeError('Landing-page result evidence is missing');
+                evidence.returned = {
+                    contentId: created.contentId,
+                    contentKey: created.contentKey,
+                    primaryVariantId: created.primaryVariantId,
+                    state: 'unverified',
+                };
+            }
             await persistOperationResult(reportFile, report, parentOperation, rewrite);
             if (native) {
                 if (source.items.some((item) => item.contentKey === created.contentKey ||
@@ -984,9 +1232,12 @@ export async function executeWorkspaceImport(options) {
     }
     return {
         diagnostics: editableDiagnostics,
-        contractResult: importContractResult(source, options.destinationOrgId, plan, mappings, references),
+        contractResult: importContractResult(source, options.destinationOrgId, plan, mappings, references, report.templatePrerequisites),
         dryRun: false,
         plan,
+        ...(report.templatePrerequisites === undefined
+            ? {}
+            : { templatePrerequisites: report.templatePrerequisites }),
         report,
         reportFile,
     };