sb-mig 6.2.0 → 6.3.0-beta.2

package/dist/api/copy/reference-rewriter.js

@@ -0,0 +1,153 @@
+const RESERVED_CONTENT_KEYS = new Set(["_uid", "component", "_editable"]);
+export const rewriteCopyReferences = ({ value, maps, schemas, }) => {
+    const clonedValue = cloneJson(value);
+    const state = {
+        maps,
+        schemas,
+        records: [],
+        warnings: [],
+    };
+    rewriteNode(clonedValue, "$", state);
+    return {
+        value: clonedValue,
+        records: state.records,
+        warnings: state.warnings,
+    };
+};
+const cloneJson = (value) => JSON.parse(JSON.stringify(value));
+const rewriteNode = (node, path, state) => {
+    if (Array.isArray(node)) {
+        node.forEach((item, index) => rewriteNode(item, `${path}[${index}]`, state));
+        return;
+    }
+    if (!isRecord(node)) {
+        return;
+    }
+    rewriteAssetObject(node, path, state);
+    rewriteStoryLinkObject(node, path, state);
+    rewriteRichtextLinkObject(node, path, state);
+    rewriteSchemaAwareOptions(node, path, state);
+    if (node.type === "blok" &&
+        isRecord(node.attrs) &&
+        Array.isArray(node.attrs.body)) {
+        node.attrs.body.forEach((blok, index) => rewriteNode(blok, `${path}.attrs.body[${index}]`, state));
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "attrs" && (node.type === "link" || node.type === "blok")) {
+            continue;
+        }
+        rewriteNode(value, `${path}.${key}`, state);
+    }
+};
+const rewriteAssetObject = (node, path, state) => {
+    const hasAssetShape = typeof node.filename === "string" &&
+        (typeof node.id === "number" ||
+            state.maps.assetFilenames.has(node.filename));
+    if (!hasAssetShape) {
+        return;
+    }
+    const targetById = typeof node.id === "number"
+        ? state.maps.assetIds.get(node.id)
+        : undefined;
+    const targetFilename = targetById?.filename ?? state.maps.assetFilenames.get(node.filename);
+    if (typeof node.id === "number" && targetById) {
+        addRecord(state, {
+            type: "asset",
+            path: `${path}.id`,
+            sourceValue: node.id,
+            targetValue: targetById.id,
+            field: "id",
+        });
+        node.id = targetById.id;
+    }
+    if (targetFilename && node.filename !== targetFilename) {
+        addRecord(state, {
+            type: "asset",
+            path: `${path}.filename`,
+            sourceValue: node.filename,
+            targetValue: targetFilename,
+            field: "filename",
+        });
+        node.filename = targetFilename;
+    }
+};
+const rewriteStoryLinkObject = (node, path, state) => {
+    if (node.linktype !== "story") {
+        return;
+    }
+    if (typeof node.id === "number") {
+        const targetId = state.maps.storyIds.get(node.id);
+        if (targetId !== undefined) {
+            addRecord(state, {
+                type: "story",
+                path: `${path}.id`,
+                sourceValue: node.id,
+                targetValue: targetId,
+                field: "id",
+            });
+            node.id = targetId;
+        }
+    }
+    if (typeof node.uuid === "string") {
+        const targetUuid = state.maps.storyUuids.get(node.uuid);
+        if (targetUuid !== undefined) {
+            addRecord(state, {
+                type: "story",
+                path: `${path}.uuid`,
+                sourceValue: node.uuid,
+                targetValue: targetUuid,
+                field: "uuid",
+            });
+            node.uuid = targetUuid;
+        }
+    }
+};
+const rewriteRichtextLinkObject = (node, path, state) => {
+    if (node.type !== "link" || !isRecord(node.attrs)) {
+        return;
+    }
+    rewriteStoryLinkObject(node.attrs, `${path}.attrs`, state);
+};
+const rewriteSchemaAwareOptions = (node, path, state) => {
+    if (!state.schemas || typeof node.component !== "string") {
+        return;
+    }
+    const schema = state.schemas[node.component];
+    if (!schema) {
+        return;
+    }
+    for (const [fieldName, fieldValue] of Object.entries(node)) {
+        if (RESERVED_CONTENT_KEYS.has(fieldName) ||
+            !Array.isArray(fieldValue)) {
+            continue;
+        }
+        const fieldSchema = getFieldSchema(schema, fieldName);
+        if (fieldSchema?.type !== "options" ||
+            fieldSchema.source !== "internal_stories") {
+            continue;
+        }
+        fieldValue.forEach((item, index) => {
+            if (typeof item !== "number") {
+                return;
+            }
+            const targetId = state.maps.storyIds.get(item);
+            if (targetId === undefined) {
+                return;
+            }
+            addRecord(state, {
+                type: "story",
+                path: `${path}.${fieldName}[${index}]`,
+                sourceValue: item,
+                targetValue: targetId,
+                field: "id",
+            });
+            fieldValue[index] = targetId;
+        });
+    }
+};
+const getFieldSchema = (schema, fieldName) => schema[fieldName] ?? schema[normalizeFieldName(fieldName)];
+const normalizeFieldName = (fieldName) => fieldName.replace(/[-_]+([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
+const addRecord = (state, record) => {
+    state.records.push(record);
+};
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);

package/dist/api/copy/reference-scanner.d.ts

@@ -0,0 +1,23 @@
+import type { CopyComponentSchemaRegistry, CopyReferenceScannerOptions, CopyReferenceScannerResult } from "./types.js";
+type StoryLike = {
+    id?: number;
+    uuid?: string;
+    full_slug?: string;
+    parent_id?: number | null;
+    alternates?: Array<{
+        id?: number;
+        parent_id?: number | null;
+    }>;
+    content?: Record<string, unknown>;
+};
+export declare const scanStoryReferences: ({ story, schemas, options, }: {
+    story: StoryLike;
+    schemas: CopyComponentSchemaRegistry;
+    options?: CopyReferenceScannerOptions;
+}) => CopyReferenceScannerResult;
+export declare const scanStoriesReferences: ({ stories, schemas, options, }: {
+    stories: StoryLike[];
+    schemas: CopyComponentSchemaRegistry;
+    options?: CopyReferenceScannerOptions;
+}) => CopyReferenceScannerResult;
+export {};

package/dist/api/copy/reference-scanner.js

@@ -0,0 +1,322 @@
+const RESERVED_CONTENT_KEYS = new Set(["_uid", "component", "_editable"]);
+export const scanStoryReferences = ({ story, schemas, options = {}, }) => {
+    const state = {
+        schemas,
+        options: {
+            referencePolicy: options.referencePolicy ?? "preserve",
+        },
+        context: {
+            sourceStoryId: story.id,
+            sourceStoryUuid: story.uuid,
+            sourceStoryFullSlug: story.full_slug,
+        },
+        storyReferences: [],
+        assetReferences: [],
+        assetNodesByKey: new Map(),
+        opaqueFields: [],
+        warnings: [],
+        errors: [],
+        missingSchemas: new Set(),
+    };
+    scanStoryMetadata(story, state);
+    scanComponentNode(story.content, "content", state);
+    return {
+        storyReferences: state.storyReferences,
+        assetReferences: state.assetReferences,
+        assetNodes: Array.from(state.assetNodesByKey.values()),
+        opaqueFields: state.opaqueFields,
+        warnings: state.warnings,
+        errors: state.errors,
+        missingSchemas: Array.from(state.missingSchemas),
+    };
+};
+export const scanStoriesReferences = ({ stories, schemas, options = {}, }) => {
+    const combined = {
+        storyReferences: [],
+        assetReferences: [],
+        assetNodes: [],
+        opaqueFields: [],
+        warnings: [],
+        errors: [],
+        missingSchemas: [],
+    };
+    const assetNodesByKey = new Map();
+    const missingSchemas = new Set();
+    stories.forEach((story, index) => {
+        const result = scanStoryReferences({ story, schemas, options });
+        combined.storyReferences.push(...result.storyReferences);
+        combined.assetReferences.push(...result.assetReferences);
+        combined.opaqueFields.push(...result.opaqueFields);
+        combined.warnings.push(...result.warnings);
+        combined.errors.push(...result.errors);
+        for (const schemaName of result.missingSchemas) {
+            missingSchemas.add(schemaName);
+        }
+        for (const assetNode of result.assetNodes) {
+            assetNodesByKey.set(getAssetNodeKey(assetNode), assetNode);
+        }
+        const scanned = index + 1;
+        if (options.onProgress &&
+            (scanned === stories.length ||
+                scanned % 10 === 0 ||
+                stories.length <= 10)) {
+            options.onProgress({
+                scanned,
+                total: stories.length,
+                storyFullSlug: story.full_slug,
+            });
+        }
+    });
+    combined.assetNodes = Array.from(assetNodesByKey.values());
+    combined.missingSchemas = Array.from(missingSchemas);
+    return combined;
+};
+const scanStoryMetadata = (story, state) => {
+    if (typeof story.parent_id === "number") {
+        addStoryReference(state, {
+            path: "parent_id",
+            referencedStoryId: story.parent_id,
+        });
+    }
+    story.alternates?.forEach((alternate, index) => {
+        if (typeof alternate.id === "number") {
+            addStoryReference(state, {
+                path: `alternates[${index}].id`,
+                referencedStoryId: alternate.id,
+            });
+        }
+        if (typeof alternate.parent_id === "number") {
+            addStoryReference(state, {
+                path: `alternates[${index}].parent_id`,
+                referencedStoryId: alternate.parent_id,
+            });
+        }
+    });
+};
+const scanComponentNode = (node, path, state) => {
+    if (!isRecord(node)) {
+        return;
+    }
+    const component = node.component;
+    if (typeof component !== "string" || component.length === 0) {
+        return;
+    }
+    const schema = state.schemas[component];
+    if (!schema) {
+        state.missingSchemas.add(component);
+        state.warnings.push({
+            code: "missing_component_schema",
+            message: `Component schema '${component}' was not found. References inside this component were not scanned.`,
+            path,
+        });
+        state.opaqueFields.push({
+            type: "opaque_field",
+            ...state.context,
+            component,
+            field: component,
+            path,
+            reason: "unknown_schema",
+        });
+        return;
+    }
+    for (const [fieldName, fieldValue] of Object.entries(node)) {
+        if (RESERVED_CONTENT_KEYS.has(fieldName)) {
+            continue;
+        }
+        const normalizedFieldName = normalizeFieldName(fieldName);
+        const fieldSchema = schema[normalizedFieldName];
+        const fieldPath = `${path}.${fieldName}`;
+        if (!fieldSchema) {
+            addOpaqueField(state, {
+                component,
+                field: normalizedFieldName,
+                path: fieldPath,
+                reason: "unsupported_field",
+            });
+            continue;
+        }
+        if (typeof fieldSchema.plugin === "string") {
+            addOpaqueField(state, {
+                component,
+                field: normalizedFieldName,
+                fieldType: fieldSchema.type,
+                plugin: fieldSchema.plugin,
+                path: fieldPath,
+                reason: "plugin_field",
+            });
+        }
+        scanField({
+            component,
+            fieldName: normalizedFieldName,
+            fieldValue,
+            fieldSchema,
+            path: fieldPath,
+            state,
+        });
+    }
+};
+const scanField = ({ fieldValue, fieldSchema, path, state, }) => {
+    switch (fieldSchema.type) {
+        case "asset":
+            scanAssetField(fieldValue, path, state);
+            return;
+        case "multiasset":
+            scanMultiassetField(fieldValue, path, state);
+            return;
+        case "multilink":
+            scanMultilinkField(fieldValue, path, state);
+            return;
+        case "options":
+            scanOptionsField(fieldValue, fieldSchema, path, state);
+            return;
+        case "bloks":
+            scanBloksField(fieldValue, path, state);
+            return;
+        case "richtext":
+            scanRichtextField(fieldValue, path, state);
+            return;
+        default:
+            return;
+    }
+};
+const scanAssetField = (fieldValue, path, state) => {
+    if (!isRecord(fieldValue)) {
+        return;
+    }
+    const assetId = typeof fieldValue.id === "number" ? fieldValue.id : undefined;
+    const filename = typeof fieldValue.filename === "string"
+        ? fieldValue.filename
+        : undefined;
+    if (assetId === undefined && !filename) {
+        return;
+    }
+    const reference = {
+        type: "asset_reference",
+        ...state.context,
+        assetId,
+        filename,
+        path,
+        status: "planned",
+    };
+    state.assetReferences.push(reference);
+    if (assetId !== undefined && filename) {
+        const node = {
+            type: "asset",
+            sourceId: assetId,
+            sourceFilename: filename,
+            action: "unknown",
+        };
+        state.assetNodesByKey.set(getAssetNodeKey(node), node);
+    }
+};
+const scanMultiassetField = (fieldValue, path, state) => {
+    if (!Array.isArray(fieldValue)) {
+        state.warnings.push({
+            code: "invalid_multiasset_field",
+            message: "Expected multiasset field to be an array.",
+            path,
+            sourceValue: fieldValue,
+        });
+        return;
+    }
+    fieldValue.forEach((asset, index) => scanAssetField(asset, `${path}[${index}]`, state));
+};
+const scanMultilinkField = (fieldValue, path, state) => {
+    if (!isRecord(fieldValue) || fieldValue.linktype !== "story") {
+        return;
+    }
+    const referencedStoryId = typeof fieldValue.id === "number" ? fieldValue.id : undefined;
+    if (referencedStoryId === undefined) {
+        return;
+    }
+    addStoryReference(state, {
+        path: `${path}.id`,
+        referencedStoryId,
+    });
+};
+const scanOptionsField = (fieldValue, fieldSchema, path, state) => {
+    if (fieldSchema.source !== "internal_stories") {
+        return;
+    }
+    if (!Array.isArray(fieldValue)) {
+        return;
+    }
+    fieldValue.forEach((value, index) => {
+        if (typeof value === "number") {
+            addStoryReference(state, {
+                path: `${path}[${index}]`,
+                referencedStoryId: value,
+            });
+        }
+    });
+};
+const scanBloksField = (fieldValue, path, state) => {
+    if (!Array.isArray(fieldValue)) {
+        state.warnings.push({
+            code: "invalid_bloks_field",
+            message: "Expected bloks field to be an array.",
+            path,
+            sourceValue: fieldValue,
+        });
+        return;
+    }
+    fieldValue.forEach((blok, index) => scanComponentNode(blok, `${path}[${index}]`, state));
+};
+const scanRichtextField = (fieldValue, path, state) => {
+    scanRichtextNode(fieldValue, path, state);
+};
+const scanRichtextNode = (node, path, state) => {
+    if (Array.isArray(node)) {
+        node.forEach((item, index) => scanRichtextNode(item, `${path}[${index}]`, state));
+        return;
+    }
+    if (!isRecord(node)) {
+        return;
+    }
+    if (node.type === "link" && isRecord(node.attrs)) {
+        const attrs = node.attrs;
+        if (attrs.linktype === "story" && typeof attrs.uuid === "string") {
+            addStoryReference(state, {
+                path: `${path}.attrs.uuid`,
+                referencedStoryUuid: attrs.uuid,
+            });
+        }
+    }
+    if (node.type === "blok" && isRecord(node.attrs)) {
+        const body = node.attrs.body;
+        if (Array.isArray(body)) {
+            body.forEach((blok, index) => scanComponentNode(blok, `${path}.attrs.body[${index}]`, state));
+        }
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (key === "attrs" && (node.type === "link" || node.type === "blok")) {
+            continue;
+        }
+        scanRichtextNode(value, `${path}.${key}`, state);
+    }
+};
+const addStoryReference = (state, reference) => {
+    state.storyReferences.push({
+        type: "story_reference",
+        ...state.context,
+        ...reference,
+        status: state.options.referencePolicy === "preserve"
+            ? "preserved_external"
+            : "unresolved",
+    });
+};
+const addOpaqueField = (state, field) => {
+    state.opaqueFields.push({
+        type: "opaque_field",
+        ...state.context,
+        ...field,
+    });
+    state.warnings.push({
+        code: field.reason,
+        message: `Field '${field.component}.${field.field}' may contain references that cannot be safely scanned yet.`,
+        path: field.path,
+    });
+};
+const normalizeFieldName = (fieldName) => fieldName.replace(/__i18n__.*/, "");
+const getAssetNodeKey = (asset) => `${asset.sourceId}:${asset.sourceFilename}`;
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);

package/dist/api/copy/types.d.ts

@@ -0,0 +1,196 @@
+export type CopyResourceType = "story" | "asset" | "asset_folder";
+export type CopyAction = "created" | "updated" | "skipped" | "matched_by_manifest" | "matched_by_target_key" | "failed";
+export type CopyGraphAction = "create" | "update" | "skip" | "match" | "unknown";
+export type CopyWarning = {
+    code: string;
+    message: string;
+    path?: string;
+    sourceValue?: unknown;
+    targetValue?: unknown;
+};
+export type CopyError = {
+    code: string;
+    message: string;
+    path?: string;
+    sourceValue?: unknown;
+};
+type CopyManifestEntryBase = {
+    source_space_id: string;
+    target_space_id: string;
+    action: CopyAction;
+    created_at: string;
+};
+export type CopyStoryManifestEntry = CopyManifestEntryBase & {
+    type: "story";
+    source_id: number;
+    target_id: number;
+    source_uuid: string;
+    target_uuid: string;
+    source_full_slug?: string;
+    target_full_slug?: string;
+};
+export type CopyAssetManifestEntry = CopyManifestEntryBase & {
+    type: "asset";
+    source_id: number;
+    target_id: number;
+    source_filename: string;
+    target_filename: string;
+    source_asset_folder_id?: number | null;
+    target_asset_folder_id?: number | null;
+};
+export type CopyAssetFolderManifestEntry = CopyManifestEntryBase & {
+    type: "asset_folder";
+    source_id: number;
+    target_id: number;
+    source_name?: string;
+    target_name?: string;
+    source_parent_id?: number | null;
+    target_parent_id?: number | null;
+    source_path?: string;
+    target_path?: string;
+};
+export type CopyManifestEntry = CopyStoryManifestEntry | CopyAssetManifestEntry | CopyAssetFolderManifestEntry;
+export type CopyMaps = {
+    storyIds: Map<number, number>;
+    storyUuids: Map<string, string>;
+    assetIds: Map<number, {
+        id: number;
+        filename: string;
+    }>;
+    assetFilenames: Map<string, string>;
+    assetFolderIds: Map<number, number>;
+};
+export type CopyScope = {
+    command: "copy stories" | "copy assets" | "copy space";
+    source?: string;
+    destination?: string;
+    mode?: "subtree" | "children" | "self";
+    withAssets?: boolean;
+    referencePolicy?: "preserve" | "fail" | "include-referenced";
+};
+export type CopyGraphStoryNode = {
+    type: "story";
+    sourceId: number;
+    sourceUuid?: string;
+    sourceFullSlug: string;
+    targetFullSlug?: string;
+    isFolder?: boolean;
+    action: CopyGraphAction;
+};
+export type CopyGraphAssetNode = {
+    type: "asset";
+    sourceId: number;
+    sourceFilename: string;
+    targetFilename?: string;
+    sourceAssetFolderId?: number | null;
+    targetAssetFolderId?: number | null;
+    action: CopyGraphAction;
+};
+export type CopyGraphAssetFolderNode = {
+    type: "asset_folder";
+    sourceId: number;
+    sourcePath?: string;
+    targetPath?: string;
+    sourceParentId?: number | null;
+    targetParentId?: number | null;
+    action: CopyGraphAction;
+};
+export type CopyGraphStoryReference = {
+    type: "story_reference";
+    sourceStoryId?: number;
+    sourceStoryUuid?: string;
+    sourceStoryFullSlug?: string;
+    referencedStoryId?: number;
+    referencedStoryUuid?: string;
+    path: string;
+    status: "mapped" | "preserved_external" | "unresolved" | "unsupported";
+};
+export type CopyGraphAssetReference = {
+    type: "asset_reference";
+    sourceStoryId?: number;
+    sourceStoryUuid?: string;
+    sourceStoryFullSlug?: string;
+    assetId?: number;
+    filename?: string;
+    path: string;
+    status: "planned" | "mapped" | "unresolved" | "unsupported";
+};
+export type CopyGraphOpaqueField = {
+    type: "opaque_field";
+    sourceStoryId?: number;
+    sourceStoryUuid?: string;
+    sourceStoryFullSlug?: string;
+    component: string;
+    field: string;
+    fieldType?: string;
+    plugin?: string;
+    path: string;
+    reason: "plugin_field" | "unknown_schema" | "unsupported_field";
+};
+export type CopyGraph = {
+    schemaVersion: 1;
+    sourceSpaceId: string;
+    targetSpaceId: string;
+    generatedAt: string;
+    scope: CopyScope;
+    stories: CopyGraphStoryNode[];
+    assets: CopyGraphAssetNode[];
+    assetFolders: CopyGraphAssetFolderNode[];
+    storyReferences: CopyGraphStoryReference[];
+    assetReferences: CopyGraphAssetReference[];
+    opaqueFields: CopyGraphOpaqueField[];
+    warnings: CopyWarning[];
+    errors: CopyError[];
+    limitations: string[];
+};
+export type CopyGraphSummary = {
+    stories: number;
+    assets: number;
+    assetFolders: number;
+    storyReferences: number;
+    assetReferences: number;
+    opaqueFields: number;
+    warnings: number;
+    errors: number;
+    limitations: number;
+};
+export type CopyComponentSchemaField = {
+    type?: string;
+    source?: string;
+    plugin?: string;
+    component_whitelist?: string[];
+    restrict_components?: boolean;
+    [key: string]: unknown;
+};
+export type CopyComponentSchema = Record<string, CopyComponentSchemaField>;
+export type CopyComponentSchemaRegistry = Record<string, CopyComponentSchema>;
+export type CopyReferenceScannerOptions = {
+    referencePolicy?: "preserve" | "fail" | "include-referenced";
+    onProgress?: (progress: {
+        scanned: number;
+        total: number;
+        storyFullSlug?: string;
+    }) => void;
+};
+export type CopyReferenceScannerResult = {
+    storyReferences: CopyGraphStoryReference[];
+    assetReferences: CopyGraphAssetReference[];
+    assetNodes: CopyGraphAssetNode[];
+    opaqueFields: CopyGraphOpaqueField[];
+    warnings: CopyWarning[];
+    errors: CopyError[];
+    missingSchemas: string[];
+};
+export type CopyRewriteRecord = {
+    type: "asset" | "story";
+    path: string;
+    sourceValue: unknown;
+    targetValue: unknown;
+    field: "id" | "uuid" | "filename";
+};
+export type CopyRewriteResult<T> = {
+    value: T;
+    records: CopyRewriteRecord[];
+    warnings: CopyWarning[];
+};
+export {};

package/dist/api/copy/types.js

@@ -0,0 +1 @@
+export {};