sb-mig 6.4.0 → 6.4.1-beta.1

package/dist/api/data-migration/component-data-migration.js

@@ -2,7 +2,7 @@ import path from "path";
 import chalk from "chalk";
 import { discoverMigrationConfig, discoverStories, LOOKUP_TYPE, SCOPE, } from "../../cli/utils/discover.js";
 import storyblokConfig from "../../config/config.js";
-import { createAndSaveToFile, getFileContentWithRequire, getFilesContentWithRequire, listFilesInDir, readFile, } from "../../utils/files.js";
+import { createAndSaveToFile, getFileContentWithRequire, getFilesContentWithRequire, listFilesInDir, readFile, readJsonArrayStreamed, } from "../../utils/files.js";
 import Logger from "../../utils/logger.js";
 import { modifyOrCreateAppliedMigrationsFile } from "../../utils/migrations.js";
 import { isObjectEmpty } from "../../utils/object-utils.js";
@@ -1279,6 +1279,13 @@ const readMigrationJson = async (config, filename) => {
         throw new Error(`Migration artifact is not valid JSON: migrations/${filename}`);
     }
 };
+/**
+ * Read a migration artifact that is a JSON array (e.g. the changed-items or
+ * after-full snapshots). These can exceed V8's ~512 MB max string length on
+ * large spaces, so they are streamed element by element instead of read into a
+ * single string (which would throw ERR_STRING_TOO_LONG).
+ */
+const readMigrationJsonArray = (config, filename) => readJsonArrayStreamed(`${config.sbmigWorkingDirectory}/migrations/${filename}`);
 /**
  * Discover the dry-run `continue` manifest in the migrations folder, load the
  * artifacts it points at, and reconstruct the exact inputs `finalizeMigration`
@@ -1317,7 +1324,7 @@ export const prepareContinueMigration = async ({ manifestFileName }, config) =>
     if (!artifacts?.changedItems) {
         throw new Error(`Manifest ${chosen} is missing the changed-items artifact reference.`);
     }
-    const changedItems = (await readMigrationJson(config, artifacts.changedItems));
+    const changedItems = await readMigrationJsonArray(config, artifacts.changedItems);
     const pipelineSummary = artifacts.pipelineSummary
         ? await readMigrationJson(config, artifacts.pipelineSummary)
         : null;
@@ -1337,7 +1344,7 @@ export const prepareContinueMigration = async ({ manifestFileName }, config) =>
             missingPublishedLayerRecords: [],
         };
         const publishedFinalItems = artifacts.publishedAfterFull
-            ? (await readMigrationJson(config, artifacts.publishedAfterFull))
+            ? await readMigrationJsonArray(config, artifacts.publishedAfterFull)
             : [];
         const publishedChangedIdSet = new Set((dirty.publishedChangedIds ?? []).map(String));
         publishedLayerPipelineResult = {
@@ -1348,7 +1355,7 @@ export const prepareContinueMigration = async ({ manifestFileName }, config) =>
         };
     }
     const draftFinalItems = artifacts.draftAfterFull
-        ? (await readMigrationJson(config, artifacts.draftAfterFull))
+        ? await readMigrationJsonArray(config, artifacts.draftAfterFull)
         : changedItems;
     const pipelineResult = {
         changedItems,

package/dist/cli/commands/copy.js

@@ -314,7 +314,84 @@ const getValidMappedTargetStory = async ({ sourceStory, targetStoryId, targetFul
     Logger.warning(`Ignoring stale story manifest mapping for '${sourceStory.full_slug ?? sourceStory.slug}' because target story '${targetStoryId}' was not found at the expected target path in space '${targetSpace}'.`);
     return undefined;
 };
-const assertStoryUpdateSucceeded = ({ result, sourceStory, targetStoryId, targetSpace, }) => {
+// Walk a story's content blok tree depth-first, invoking `visit` for every blok
+// (object carrying a `component`) with its path, _uid, enclosing field and the
+// component it is nested inside. Shared by the failure diagnostic and the
+// dry-run compatibility check.
+const walkContentBloks = (content, visit) => {
+    const walk = (value, path, field, parentComponent) => {
+        if (Array.isArray(value)) {
+            value.forEach((item, index) => {
+                walk(item, `${path}[${index}]`, field, parentComponent);
+            });
+            return;
+        }
+        if (!value || typeof value !== "object") {
+            return;
+        }
+        const component = typeof value.component === "string" ? value.component : undefined;
+        if (component) {
+            visit({
+                path,
+                uid: typeof value._uid === "string" ? value._uid : undefined,
+                component,
+                field,
+                parentComponent,
+            });
+        }
+        const nextParentComponent = component ?? parentComponent;
+        for (const [key, child] of Object.entries(value)) {
+            if (key === "component" || key === "_uid") {
+                continue;
+            }
+            walk(child, path ? `${path}.${key}` : key, key, nextParentComponent);
+        }
+    };
+    walk(content, "content", undefined, undefined);
+};
+// Storyblok answers a schema violation with a 422 whose body reads like
+// "The component(s) sb-content-group are not allowed in the field content".
+// Parse out the offending component name(s) and the field they were rejected in.
+const parseDisallowedComponentError = (responseText) => {
+    if (typeof responseText !== "string") {
+        return undefined;
+    }
+    const match = responseText.match(/component\(s\)\s+(.+?)\s+are not allowed in the field\s+([^\s.]+)/i);
+    if (!match || !match[1]) {
+        return undefined;
+    }
+    const components = match[1]
+        .split(",")
+        .map((component) => component.trim())
+        .filter(Boolean);
+    if (components.length === 0) {
+        return undefined;
+    }
+    return { components, field: match[2] };
+};
+// Record every place the given component(s) appear in a story's content, with
+// the path, _uid and enclosing field so a failing copy can be traced back to
+// the exact blok in the source story.
+const collectComponentPaths = (content, targetComponents) => {
+    const matches = [];
+    walkContentBloks(content, (blok) => {
+        if (targetComponents.has(blok.component)) {
+            matches.push(blok);
+        }
+    });
+    return matches;
+};
+const describeDisallowedComponentMatches = (matches) => matches
+    .map((match) => {
+    const uidLabel = match.uid ? ` (_uid ${match.uid})` : "";
+    const fieldLabel = match.field ? ` in field '${match.field}'` : "";
+    const parentLabel = match.parentComponent
+        ? ` of component '${match.parentComponent}'`
+        : "";
+    return `  - '${match.component}' at ${match.path}${fieldLabel}${parentLabel}${uidLabel}`;
+})
+    .join("\n");
+const assertStoryUpdateSucceeded = ({ result, sourceStory, targetStoryId, targetSpace, content, }) => {
     if (result?.ok !== false) {
         return;
     }
@@ -324,7 +401,23 @@ const assertStoryUpdateSucceeded = ({ result, sourceStory, targetStoryId, target
     const responseLabel = result.response
         ? ` Response: ${result.response}`
         : "";
-    throw new Error(`Failed to update copied story '${sourceStory.full_slug ?? sourceStory.slug}' in target space '${targetSpace}' (target story id ${targetStoryId}, ${statusLabel}).${responseLabel}`);
+    let disallowedLabel = "";
+    const disallowed = parseDisallowedComponentError(result.response);
+    if (disallowed && content) {
+        const matches = collectComponentPaths(content, new Set(disallowed.components));
+        const fieldLabel = disallowed.field
+            ? ` in field '${disallowed.field}'`
+            : "";
+        if (matches.length > 0) {
+            const details = describeDisallowedComponentMatches(matches);
+            disallowedLabel = `\nDisallowed component(s) [${disallowed.components.join(", ")}]${fieldLabel} located in source story content at:\n${details}`;
+            Logger.warning(`Story '${sourceStory.full_slug ?? sourceStory.slug}' (source id ${sourceStory.id}, target id ${targetStoryId}) rejected because component(s) [${disallowed.components.join(", ")}]${fieldLabel} are not allowed in the target space schema. Found at:\n${details}`);
+        }
+        else {
+            disallowedLabel = `\nComponent(s) [${disallowed.components.join(", ")}]${fieldLabel} are not allowed in the target space schema, but were not located in the rewritten content (they may live in a nested/published layer).`;
+        }
+    }
+    throw new Error(`Failed to update copied story '${sourceStory.full_slug ?? sourceStory.slug}' in target space '${targetSpace}' (source id ${sourceStory.id}, target story id ${targetStoryId}, ${statusLabel}).${responseLabel}${disallowedLabel}`);
 };
 const isStoryUpdateNotFound = (result) => result?.ok === false && Number(result.status) === 404;
 const buildCopyPlan = (tree, destination) => {
@@ -398,6 +491,37 @@ const buildDryRunWarnings = ({ conflicts, withAssets, }) => [
             },
         ]),
 ];
+const uniqueSorted = (values) => [...new Set(values)].filter(Boolean).sort();
+const summarizeComponentCompatibility = (checked, findings) => ({
+    checked,
+    missingComponents: uniqueSorted(findings
+        .filter((finding) => finding.reason === "missing_in_target")
+        .map((finding) => finding.component)),
+    disallowedInFieldComponents: uniqueSorted(findings
+        .filter((finding) => finding.reason === "not_allowed_in_field")
+        .map((finding) => finding.component)),
+    findings,
+});
+const buildComponentCompatibilityWarnings = (componentCompatibility) => {
+    if (!componentCompatibility ||
+        componentCompatibility.findings.length === 0) {
+        return [];
+    }
+    const warnings = [];
+    if (componentCompatibility.missingComponents.length > 0) {
+        warnings.push({
+            code: "component_missing_in_target",
+            message: `Component(s) missing from the target space schema (story updates will fail with a 422 until they are synced): ${componentCompatibility.missingComponents.join(", ")}.`,
+        });
+    }
+    if (componentCompatibility.disallowedInFieldComponents.length > 0) {
+        warnings.push({
+            code: "component_not_allowed_in_field",
+            message: `Component(s) used in a field the target space schema restricts (story updates will fail with a 422): ${componentCompatibility.disallowedInFieldComponents.join(", ")}.`,
+        });
+    }
+    return warnings;
+};
 const quoteCommandArg = (value) => /^[a-zA-Z0-9_./:-]+$/.test(value) ? value : JSON.stringify(value);
 const buildCopyCommand = ({ sourceSpace, targetSpace, selection, destination, withAssets, dryRun, outputPath, }) => {
     const args = [
@@ -549,9 +673,12 @@ const buildAssetReferenceSummary = ({ graph, sourceSpace, }) => {
             .sort((left, right) => left.spaceId.localeCompare(right.spaceId)),
     };
 };
-const buildCopyDryRunReport = ({ sourceSpace, targetSpace, selection, destination, withAssets, input, plan, conflicts, graph, outputPath, }) => {
+const buildCopyDryRunReport = ({ sourceSpace, targetSpace, selection, destination, withAssets, input, plan, conflicts, graph, componentCompatibility, outputPath, }) => {
     const items = withConflictFlags(plan, conflicts);
-    const warnings = buildDryRunWarnings({ conflicts, withAssets });
+    const warnings = [
+        ...buildDryRunWarnings({ conflicts, withAssets }),
+        ...buildComponentCompatibilityWarnings(componentCompatibility),
+    ];
     const graphSummary = graph ? summarizeCopyGraph(graph) : undefined;
     const assetReferencesMapped = graph?.assetReferences.filter((reference) => reference.status === "mapped").length ?? 0;
     const assetReferencesPlanned = graph?.assetReferences.filter((reference) => reference.status === "planned").length ?? 0;
@@ -604,10 +731,12 @@ const buildCopyDryRunReport = ({ sourceSpace, targetSpace, selection, destinatio
             conflicts: conflicts.length,
             warnings: warnings.length + (graphSummary?.warnings ?? 0),
             errors: graphSummary?.errors ?? 0,
+            componentIssues: componentCompatibility?.findings.length ?? 0,
         },
         items,
         ...(graph ? { graph } : {}),
         ...(assetReferenceSummary ? { assetReferenceSummary } : {}),
+        ...(componentCompatibility ? { componentCompatibility } : {}),
         warnings,
         errors: graph?.errors ?? [],
         limitations,
@@ -962,6 +1091,96 @@ const buildComponentSchemaRegistry = async (sourceSpace) => {
         .filter((component) => component?.name && component?.schema)
         .map((component) => [component.name, component.schema]));
 };
+// Build a validator from the TARGET space component schemas so the dry-run can
+// predict the "component(s) X are not allowed in the field Y" 422 that the
+// Management API returns at write time. Two problems are detected:
+//   - a component used in a source story does not exist in the target space
+//   - a component sits in a bloks field whose target schema restricts the
+//     allowed components and does not include it
+const buildTargetComponentValidator = async (targetSpace) => {
+    const components = await managementApi.components.getAllComponents({
+        ...apiConfig,
+        spaceId: targetSpace,
+    });
+    const list = Array.isArray(components) ? components : [];
+    const targetComponentNames = new Set(list.map((component) => component?.name).filter(Boolean));
+    const schemaByName = new Map(list
+        .filter((component) => component?.name)
+        .map((component) => [component.name, component.schema ?? {}]));
+    const componentsByGroupUuid = new Map();
+    for (const component of list) {
+        const groupUuid = component?.component_group_uuid;
+        if (!component?.name || !groupUuid) {
+            continue;
+        }
+        const existing = componentsByGroupUuid.get(String(groupUuid)) ?? new Set();
+        existing.add(component.name);
+        componentsByGroupUuid.set(String(groupUuid), existing);
+    }
+    // Allowed child components for a restricted bloks field, or undefined when
+    // the field is unrestricted or cannot be resolved with confidence (which
+    // keeps the dry-run free of false positives).
+    const resolveAllowedComponents = (parentComponent, field) => {
+        if (!parentComponent || !field) {
+            return undefined;
+        }
+        const fieldDef = schemaByName.get(parentComponent)?.[field];
+        if (!fieldDef || fieldDef.type !== "bloks") {
+            return undefined;
+        }
+        if (fieldDef.restrict_components !== true) {
+            return undefined;
+        }
+        // Tag-based whitelists reference internal tag ids we do not resolve.
+        if (fieldDef.restrict_type === "tags") {
+            return undefined;
+        }
+        const allowed = new Set();
+        for (const name of fieldDef.component_whitelist ?? []) {
+            if (typeof name === "string") {
+                allowed.add(name);
+            }
+        }
+        for (const groupUuid of fieldDef.component_group_whitelist ?? []) {
+            const names = componentsByGroupUuid.get(String(groupUuid));
+            if (names) {
+                names.forEach((name) => allowed.add(name));
+            }
+        }
+        return allowed;
+    };
+    return {
+        // With no components fetched we cannot validate anything; skip instead
+        // of reporting every component as missing.
+        canValidate: targetComponentNames.size > 0,
+        validateStory(story) {
+            const findings = [];
+            walkContentBloks(story?.content, (blok) => {
+                const base = {
+                    sourceStoryId: Number(story?.id),
+                    sourceFullSlug: String(story?.full_slug ?? story?.slug ?? ""),
+                    component: blok.component,
+                    path: blok.path,
+                    uid: blok.uid,
+                    field: blok.field,
+                    parentComponent: blok.parentComponent,
+                };
+                if (!targetComponentNames.has(blok.component)) {
+                    findings.push({ ...base, reason: "missing_in_target" });
+                    return;
+                }
+                const allowed = resolveAllowedComponents(blok.parentComponent, blok.field);
+                if (allowed && !allowed.has(blok.component)) {
+                    findings.push({
+                        ...base,
+                        reason: "not_allowed_in_field",
+                    });
+                }
+            });
+            return findings;
+        },
+    };
+};
 const collectAssetFolderAncestors = ({ assets, assetFolders, }) => {
     const folderById = new Map(assetFolders.map((folder) => [Number(folder.id), folder]));
     const selectedFolderIds = new Set();
@@ -1227,6 +1446,7 @@ const rewriteCopiedStoryContents = async ({ tree, realParentId, sourceStoryById,
     const schemas = await buildComponentSchemaRegistry(sourceSpace);
     let updatedStories = 0;
     let rewrittenReferences = 0;
+    const failures = [];
     const writeStoryMapping = async ({ sourceStory, targetStory, targetFullSlug, action, }) => {
         const entry = {
             type: "story",
@@ -1294,11 +1514,26 @@ const rewriteCopiedStoryContents = async ({ tree, realParentId, sourceStoryById,
             }
             let targetStoryId = maps.storyIds.get(Number(sourceStory.id));
             if (!targetStoryId) {
-                targetStoryId = await createOrMatchReplacementShell({
-                    node,
-                    sourceStory,
-                    parentId,
-                });
+                try {
+                    targetStoryId = await createOrMatchReplacementShell({
+                        node,
+                        sourceStory,
+                        parentId,
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    Logger.error(message);
+                    failures.push({
+                        sourceId: Number(sourceStory.id),
+                        fullSlug: String(sourceStory.full_slug ?? sourceStory.slug ?? ""),
+                        stage: "create-shell",
+                        message,
+                    });
+                    // No target shell means children cannot be parented; skip
+                    // this branch but keep copying the rest of the tree.
+                    continue;
+                }
             }
             const writeStory = async (id) => {
                 const current = buildRewrittenStoryPayload({
@@ -1328,6 +1563,7 @@ const rewriteCopiedStoryContents = async ({ tree, realParentId, sourceStoryById,
                     if (!publishedUpdateResult?.ok) {
                         return {
                             result: publishedUpdateResult,
+                            content: publishedLayer.payload?.content,
                             rewrittenReferences: current.rewrittenReferences +
                                 publishedLayer.rewrittenReferences,
                         };
@@ -1341,6 +1577,7 @@ const rewriteCopiedStoryContents = async ({ tree, realParentId, sourceStoryById,
                     if (!publishResult?.ok) {
                         return {
                             result: publishResult,
+                            content: publishedLayer.payload?.content,
                             rewrittenReferences: current.rewrittenReferences +
                                 publishedLayer.rewrittenReferences,
                         };
@@ -1354,6 +1591,7 @@ const rewriteCopiedStoryContents = async ({ tree, realParentId, sourceStoryById,
                     });
                     return {
                         result: restoreDraftResult,
+                        content: current.payload?.content,
                         rewrittenReferences: current.rewrittenReferences +
                             publishedLayer.rewrittenReferences,
                     };
@@ -1380,37 +1618,64 @@ const rewriteCopiedStoryContents = async ({ tree, realParentId, sourceStoryById,
                     if (!publishResult?.ok) {
                         return {
                             result: publishResult,
+                            content: current.payload?.content,
                             rewrittenReferences: current.rewrittenReferences,
                         };
                     }
                 }
                 return {
                     result,
+                    content: current.payload?.content,
                     rewrittenReferences: current.rewrittenReferences,
                 };
             };
-            let update = await writeStory(Number(targetStoryId));
-            if (isStoryUpdateNotFound(update.result)) {
-                Logger.warning(`Ignoring stale story manifest mapping for '${sourceStory.full_slug ?? sourceStory.slug}' because target story '${targetStoryId}' could not be updated in space '${targetSpace}'.`);
-                maps.storyIds.delete(Number(sourceStory.id));
-                maps.storyUuids.delete(String(sourceStory.uuid));
-                targetStoryId = await createOrMatchReplacementShell({
-                    node,
+            // A single broken story (e.g. a component the target space schema
+            // rejects) must not abort the whole run. Record the failure, keep
+            // its already-created shell as the parent for descendants, and move
+            // on to the next story.
+            let targetInvalidated = false;
+            try {
+                let update = await writeStory(Number(targetStoryId));
+                if (isStoryUpdateNotFound(update.result)) {
+                    Logger.warning(`Ignoring stale story manifest mapping for '${sourceStory.full_slug ?? sourceStory.slug}' because target story '${targetStoryId}' could not be updated in space '${targetSpace}'.`);
+                    maps.storyIds.delete(Number(sourceStory.id));
+                    maps.storyUuids.delete(String(sourceStory.uuid));
+                    targetInvalidated = true;
+                    targetStoryId = await createOrMatchReplacementShell({
+                        node,
+                        sourceStory,
+                        parentId,
+                        staleTargetId: Number(targetStoryId),
+                    });
+                    targetInvalidated = false;
+                    update = await writeStory(Number(targetStoryId));
+                }
+                assertStoryUpdateSucceeded({
+                    result: update.result,
                     sourceStory,
-                    parentId,
-                    staleTargetId: Number(targetStoryId),
+                    targetStoryId: Number(targetStoryId),
+                    targetSpace,
+                    content: update.content,
                 });
-                update = await writeStory(Number(targetStoryId));
+                updatedStories += 1;
+                rewrittenReferences += update.rewrittenReferences;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                Logger.error(message);
+                failures.push({
+                    sourceId: Number(sourceStory.id),
+                    targetId: targetStoryId ? Number(targetStoryId) : undefined,
+                    fullSlug: String(sourceStory.full_slug ?? sourceStory.slug ?? ""),
+                    stage: "update",
+                    message,
+                });
+            }
+            // Only recurse into children when we still have a usable target
+            // shell to parent them under.
+            if (!targetInvalidated && targetStoryId) {
+                await walk(node.children ?? [], Number(targetStoryId));
             }
-            assertStoryUpdateSucceeded({
-                result: update.result,
-                sourceStory,
-                targetStoryId: Number(targetStoryId),
-                targetSpace,
-            });
-            updatedStories += 1;
-            rewrittenReferences += update.rewrittenReferences;
-            await walk(node.children ?? [], Number(targetStoryId));
         }
     };
     await walk(tree, realParentId);
@@ -1419,6 +1684,21 @@ const rewriteCopiedStoryContents = async ({ tree, realParentId, sourceStoryById,
     if (updatedStories > 0) {
         Logger.success(`Updated ${updatedStories} copied story/story shell(s); rewrote ${rewrittenReferences} reference(s).`);
     }
+    if (failures.length > 0) {
+        Logger.error(`${failures.length} story/story shell update(s) failed; the rest of the copy still completed. Failed stories:`);
+        for (const failure of failures) {
+            const targetLabel = failure.targetId
+                ? `, target id ${failure.targetId}`
+                : "";
+            Logger.error(`  - ${failure.fullSlug || "<unknown>"} (source id ${failure.sourceId}${targetLabel}) [${failure.stage}]`);
+        }
+        // Every story was still attempted (no early abort), but surface the
+        // failures so apply mode exits non-zero instead of reporting success.
+        throw new Error(`Copy finished but ${failures.length} story/story shell update(s) failed:\n${failures
+            .map((failure) => failure.message)
+            .join("\n")}`);
+    }
+    return { updatedStories, rewrittenReferences, failures };
 };
 const createStoriesAndWriteManifests = async ({ tree, realParentId, sourceStoryById, targetSlugBySourceSlug, sourceSpace, targetSpace, manifestRoot, }) => {
     const manifestPaths = getDefaultCopyManifestPaths({
@@ -1818,6 +2098,46 @@ const logDryRunCopyPlan = async ({ report }) => {
             Logger.warning(`[dry-run]   asset_ref ${reference.status.padEnd(10)} ${reference.filename ?? reference.assetId ?? "<unknown>"} at ${reference.sourceStoryFullSlug ?? reference.path}`);
         }
     }
+    const compatibility = report.componentCompatibility;
+    if (compatibility && !compatibility.checked) {
+        Logger.warning("[dry-run] Component compatibility check skipped (no target components resolved).");
+    }
+    else if (compatibility && compatibility.findings.length === 0) {
+        Logger.success("[dry-run] All source components are accepted by the target space schema.");
+    }
+    else if (compatibility) {
+        Logger.error(`[dry-run] ${compatibility.findings.length} component compatibility issue(s) would make story updates fail with a 422:`);
+        // Group by component + reason so the output stays readable when the
+        // same component is used across many stories.
+        const grouped = new Map();
+        for (const finding of compatibility.findings) {
+            const key = `${finding.reason}::${finding.component}`;
+            const bucket = grouped.get(key) ?? {
+                reason: finding.reason,
+                component: finding.component,
+                findings: [],
+            };
+            bucket.findings.push(finding);
+            grouped.set(key, bucket);
+        }
+        for (const bucket of grouped.values()) {
+            const reasonLabel = bucket.reason === "missing_in_target"
+                ? "missing from target space schema"
+                : "not allowed in the target field";
+            const example = bucket.findings[0];
+            const contextParts = [
+                example?.field ? `field '${example.field}'` : undefined,
+                example?.parentComponent
+                    ? `component '${example.parentComponent}'`
+                    : undefined,
+                example?.uid ? `_uid ${example.uid}` : undefined,
+            ].filter(Boolean);
+            const exampleLabel = example
+                ? ` e.g. '${example.sourceFullSlug}' at ${example.path}${contextParts.length ? ` (${contextParts.join(", ")})` : ""}`
+                : "";
+            Logger.error(`[dry-run]   ${bucket.component}: ${reasonLabel} — ${bucket.findings.length} occurrence(s).${exampleLabel}`);
+        }
+    }
     report.warnings.forEach((warning) => Logger.warning(`[dry-run] ${warning.message}`));
 };
 const logDryRunCopyAssetsPlan = async ({ report, }) => {
@@ -1937,6 +2257,14 @@ export const copyCommand = async (props) => {
             }
             if (dryRun) {
                 const conflicts = await findTargetConflicts(plan, targetSpace);
+                Logger.warning("Checking source components against the target space schema.");
+                const componentValidator = await buildTargetComponentValidator(targetSpace);
+                const componentCompatibility = componentValidator.canValidate
+                    ? summarizeComponentCompatibility(true, sourceStories.flatMap((item) => componentValidator.validateStory(item?.story)))
+                    : summarizeComponentCompatibility(false, []);
+                if (!componentCompatibility.checked) {
+                    Logger.warning(`Skipped component compatibility check because no components were returned for target space '${targetSpace}'.`);
+                }
                 Logger.warning("Building dry-run copy report.");
                 const report = buildCopyDryRunReport({
                     sourceSpace,
@@ -1948,6 +2276,7 @@ export const copyCommand = async (props) => {
                     plan,
                     conflicts,
                     graph: dryRunGraph,
+                    componentCompatibility,
                     outputPath,
                 });
                 await logDryRunCopyPlan({ report });

package/dist/utils/files.d.ts

@@ -39,6 +39,7 @@ export declare const isDirectoryExists: (path: string) => boolean;
 export declare const createDir: (dirPath: string) => Promise<void>;
 export declare const createJsonFile: (content: string, pathWithFilename: string) => Promise<void>;
 export declare const writeJsonArrayStreamed: (items: any[], pathWithFilename: string) => Promise<void>;
+export declare const readJsonArrayStreamed: (pathToFile: string) => Promise<any[]>;
 export declare const createJSAllComponentsFile: (content: string, pathWithFilename: string, timestamp?: boolean) => Promise<void>;
 export declare const copyFolder: (src: string, dest: string) => Promise<unknown>;
 export declare const copyFile: (src: string, dest: string) => Promise<void>;

package/dist/utils/files.js

@@ -153,6 +153,136 @@ export const writeJsonArrayStreamed = (items, pathWithFilename) => {
         });
     });
 };
+/*
+ * Streams a top-level JSON array from disk, parsing one element at a time.
+ * The counterpart to writeJsonArrayStreamed: large migration artifacts are
+ * written without ever building the whole document as a single string, so they
+ * must also be READ without `fs.readFile(...).toString()`, which throws
+ * ERR_STRING_TOO_LONG once the file passes V8's ~512 MB max string length.
+ *
+ * Only the array document is streamed; each individual element is parsed with
+ * JSON.parse (elements are small). Throws if the file is not a JSON array.
+ */
+export const readJsonArrayStreamed = (pathToFile) => {
+    return new Promise((resolve, reject) => {
+        const stream = fs.createReadStream(resolveFromCwd(pathToFile), {
+            encoding: "utf8",
+        });
+        const items = [];
+        let started = false; // seen the opening `[`
+        let done = false; // seen the matching top-level `]`
+        let buffer = ""; // current element text
+        let depth = 0; // nesting depth inside the current element
+        let inString = false;
+        let escaped = false;
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            stream.destroy();
+            reject(err);
+        };
+        const flushElement = () => {
+            const text = buffer.trim();
+            buffer = "";
+            if (text.length === 0) {
+                return;
+            }
+            items.push(JSON.parse(text));
+        };
+        stream.on("data", (rawChunk) => {
+            if (done)
+                return;
+            // The stream is opened with utf8 encoding, so chunks arrive as
+            // strings (decoded across multi-byte boundaries). The Buffer arm is
+            // only here to satisfy the Node type signature.
+            const chunk = typeof rawChunk === "string"
+                ? rawChunk
+                : rawChunk.toString("utf8");
+            for (let i = 0; i < chunk.length; i++) {
+                const ch = chunk[i];
+                if (!started) {
+                    if (ch === "[") {
+                        started = true;
+                    }
+                    else if (ch.trim() !== "") {
+                        fail(new Error(`Expected a JSON array in ${pathToFile}, found "${ch}".`));
+                        return;
+                    }
+                    continue;
+                }
+                if (inString) {
+                    buffer += ch;
+                    if (escaped) {
+                        escaped = false;
+                    }
+                    else if (ch === "\\") {
+                        escaped = true;
+                    }
+                    else if (ch === '"') {
+                        inString = false;
+                    }
+                    continue;
+                }
+                if (ch === '"') {
+                    inString = true;
+                    buffer += ch;
+                    continue;
+                }
+                if (ch === "{" || ch === "[") {
+                    depth++;
+                    buffer += ch;
+                    continue;
+                }
+                if (ch === "}") {
+                    depth--;
+                    buffer += ch;
+                    continue;
+                }
+                if (ch === "]") {
+                    if (depth === 0) {
+                        // closing the top-level array
+                        try {
+                            flushElement();
+                        }
+                        catch (error) {
+                            fail(error);
+                            return;
+                        }
+                        done = true;
+                        break;
+                    }
+                    depth--;
+                    buffer += ch;
+                    continue;
+                }
+                if (ch === "," && depth === 0) {
+                    try {
+                        flushElement();
+                    }
+                    catch (error) {
+                        fail(error);
+                        return;
+                    }
+                    continue;
+                }
+                buffer += ch;
+            }
+        });
+        stream.on("error", fail);
+        stream.on("end", () => {
+            if (settled)
+                return;
+            if (!started) {
+                fail(new Error(`Empty or non-JSON file: ${pathToFile}`));
+                return;
+            }
+            settled = true;
+            resolve(items);
+        });
+    });
+};
 export const createJSAllComponentsFile = async (content, pathWithFilename, timestamp = false) => {
     const datestamp = new Date();
     const finalContent = `/*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sb-mig",
-  "version": "6.4.0",
+  "version": "6.4.1-beta.1",
   "description": "CLI to rule the world. (and handle stuff related to Storyblok CMS)",
   "author": "Marcin Krawczyk <marckraw@icloud.com>",
   "license": "MIT",