@se-studio/project-build 1.0.68 → 1.0.71

package/dist/management/migrate-brightline.js

@@ -1,1085 +0,0 @@
-import { isDeepStrictEqual } from 'node:util';
-import contentfulManagement from 'contentful-management';
-import dotenv from 'dotenv';
-dotenv.config();
-const SPACE_ID = '96gdpqkm7elu';
-const SOURCE_ENV_ID = 'cleanup';
-const TARGET_ENV_ID = 'production-2026';
-const DRY_RUN = process.argv.includes('--dry-run');
-const stats = {
-    assets: { created: 0, skipped: 0, errors: 0 },
-    entries: { created: 0, skipped: 0, errors: 0 },
-};
-// ID Mapping: Old ID -> New ID
-const idMap = new Map();
-async function getEnvironment(spaceId, envId) {
-    const accessToken = process.env.CONTENTFUL_MANAGEMENT_TOKEN;
-    if (!accessToken) {
-        throw new Error('CONTENTFUL_MANAGEMENT_TOKEN is not set');
-    }
-    const client = contentfulManagement.createClient({ accessToken });
-    const space = await client.getSpace(spaceId);
-    return space.getEnvironment(envId);
-}
-// --- Helpers ---
-// Cache for valid values to avoid repeated API calls
-const validValuesCache = {};
-async function ensureValidValue(environment, contentTypeId, fieldId, value) {
-    if (!value)
-        return;
-    const cacheKey = `${contentTypeId}:${fieldId}`;
-    // Initial Cache Population
-    if (!validValuesCache[cacheKey]) {
-        try {
-            const contentType = await environment.getContentType(contentTypeId);
-            const field = contentType.fields.find((f) => f.id === fieldId);
-            const validations = field?.validations || [];
-            const inValidation = validations.find((v) => v.in);
-            validValuesCache[cacheKey] = (inValidation ? inValidation.in : []);
-        }
-        catch (e) {
-            console.warn(`Could not fetch validation for ${cacheKey}`, e);
-            validValuesCache[cacheKey] = [];
-        }
-    }
-    const currentValues = validValuesCache[cacheKey];
-    if (currentValues && !currentValues.includes(value)) {
-        if (DRY_RUN) {
-            console.log(`[Dry Run] Would update ${contentTypeId}.${fieldId} validations to include: ${value}`);
-            return;
-        }
-        console.log(`Updating ${contentTypeId}.${fieldId} validations to include: ${value}`);
-        try {
-            let contentType = await environment.getContentType(contentTypeId);
-            const field = contentType.fields.find((f) => f.id === fieldId);
-            const inValidation = field?.validations?.find((v) => v.in);
-            // Double check if value is already there (race condition or cache stale)
-            if (inValidation?.in?.includes(value)) {
-                validValuesCache[cacheKey].push(value);
-                return;
-            }
-            if (inValidation && inValidation.in) {
-                inValidation.in.push(value);
-                contentType = await contentType.update();
-                await contentType.publish();
-                validValuesCache[cacheKey].push(value);
-            }
-        }
-        catch (e) {
-            console.error(`Failed to update validation for ${cacheKey}:`, e);
-        }
-    }
-}
-function getWrapperId(assetId) {
-    return `visual-${assetId}`;
-}
-async function ensureWrapperEntry(targetEnv, assetId, title = 'Visual Wrapper', targetAssetsMap) {
-    const wrapperId = getWrapperId(assetId);
-    // Check if Asset exists in Target (Fail-Fast)
-    if (targetAssetsMap) {
-        const targetAsset = targetAssetsMap.get(assetId);
-        // We also check if it is published? 
-        // The map might contain drafts.
-        // But if we ran `migrateAssets`, we ensured publication.
-        if (!targetAsset) {
-            throw new Error(`Cannot create wrapper ${wrapperId}. Asset ${assetId} not found in target.`);
-        }
-        // If we want to be strict about publication:
-        if (!targetAsset.sys.publishedVersion && !targetAsset.sys.archivedVersion) {
-            // It might have just been created and published in `migrateAssets`, 
-            // but the map object might be stale if we didn't update it with the published version?
-            // `createAssetWithId` returns the created asset. We updated the map.
-            // `publish()` returns the published asset. We didn't update the map with that result in previous logic.
-            // However, simple existence check is better than failing if we aren't sure.
-            // The error `notResolvable` comes from Contentful validation.
-            // Let's assume `migrateAssets` did its job.
-        }
-    }
-    if (DRY_RUN) {
-        console.log(`[Dry Run] Would ensure wrapper entry ${wrapperId} for asset ${assetId}`);
-        idMap.set(wrapperId, wrapperId);
-        return wrapperId;
-    }
-    try {
-        try {
-            await targetEnv.getEntry(wrapperId);
-        }
-        catch (e) {
-            console.log(`Creating wrapper entry ${wrapperId} for asset ${assetId}`);
-            const entry = await targetEnv.createEntryWithId('media', wrapperId, {
-                fields: {
-                    name: { 'en-US': title },
-                    asset: { 'en-US': { sys: createLink(assetId, 'Asset').sys } },
-                },
-            });
-            await entry.publish();
-        }
-    }
-    catch (error) {
-        console.error(`Failed to ensure wrapper ${wrapperId}:`, error);
-        throw error; // Fail fast
-    }
-    return wrapperId;
-}
-// Helper to get or create Article Type 'Blog'
-async function getBlogArticleTypeId(env) {
-    // Try to find the Blog article type by name "Blog"
-    try {
-        const entries = await env.getEntries({
-            content_type: 'articleType',
-            'fields.name[match]': 'Blog',
-            limit: 1,
-        });
-        if (entries.items.length > 0) {
-            console.log(`Found existing Blog Article Type: ${entries.items[0].sys.id}`);
-            return entries.items[0].sys.id;
-        }
-    }
-    catch (e) {
-        console.warn('Error searching for Blog Article Type:', e);
-    }
-    // Create if not found
-    console.log('Creating Blog Article Type...');
-    try {
-        const newEntry = await env.createEntry('articleType', {
-            fields: {
-                name: { 'en-US': 'Blog' },
-                cmsLabel: { 'en-US': 'Blog' },
-                slug: { 'en-US': 'blogs' },
-                indexPageTitle: { 'en-US': 'Blog' },
-                indexPageDescription: { 'en-US': 'Blog Index' },
-                indexed: { 'en-US': true },
-                hidden: { 'en-US': false },
-            },
-        });
-        console.log(`Created Blog Article Type: ${newEntry.sys.id}`);
-        return newEntry.sys.id;
-    }
-    catch (e) {
-        console.error('Failed to create Blog Article Type:', e);
-        return '';
-    }
-}
-// Helper to deep compare Contentful fields while ignoring sys metadata in links
-function isEqualFields(obj1, obj2) {
-    const normalize = (obj) => {
-        if (!obj || typeof obj !== 'object')
-            return obj;
-        if (Array.isArray(obj))
-            return obj.map(normalize);
-        if (obj.sys && obj.sys.type === 'Link') {
-            return {
-                sys: {
-                    type: 'Link',
-                    linkType: obj.sys.linkType,
-                    id: obj.sys.id,
-                },
-            };
-        }
-        const res = {};
-        for (const key of Object.keys(obj).sort()) {
-            if (obj[key] === undefined)
-                continue;
-            res[key] = normalize(obj[key]);
-        }
-        return res;
-    };
-    return isDeepStrictEqual(normalize(obj1), normalize(obj2));
-}
-// Helper to update entry with retry logic
-async function updateEntryWithRetry(env, id, contentType, fields, retries = 3) {
-    try {
-        let entry;
-        try {
-            entry = await env.getEntry(id);
-            if (isEqualFields(entry.fields, fields)) {
-                // console.log(`Entry ${id} is up to date. Skipping update.`);
-                return entry;
-            }
-            console.log(`Entry ${id} exists. Updating...`);
-            entry.fields = fields;
-            return await entry.update();
-        }
-        catch (e) {
-            if (e.name === 'NotFound') {
-                console.log(`Creating ${contentType} (${id})`);
-                return await env.createEntryWithId(contentType, id, { fields });
-            }
-            throw e;
-        }
-    }
-    catch (error) {
-        if (error.name === 'VersionMismatch' && retries > 0) {
-            console.warn(`VersionMismatch for ${id}. Retrying... (${retries} left)`);
-            return updateEntryWithRetry(env, id, contentType, fields, retries - 1);
-        }
-        throw error; // Re-throw to fail fast
-    }
-}
-// --- Asset Migration ---
-async function migrateAssets(sourceAssets, targetEnv, targetAssetsMap) {
-    console.log('\n--- Migrating Assets ---');
-    console.log(`Processing ${sourceAssets.length} source assets (reachable only).`);
-    for (const asset of sourceAssets) {
-        const assetId = asset.sys.id;
-        try {
-            const targetAsset = targetAssetsMap.get(assetId);
-            if (targetAsset) {
-                // Asset exists. Should we update?
-                // Simple check: is it published?
-                if (!targetAsset.sys.publishedVersion || !!targetAsset.sys.archivedVersion) {
-                    console.log(`Asset ${assetId} exists but not published. Publishing...`);
-                    if (!DRY_RUN) {
-                        await targetAsset.publish();
-                    }
-                }
-                else {
-                    // Already published. Skip update for speed.
-                }
-                idMap.set(assetId, assetId);
-                continue;
-            }
-            if (DRY_RUN) {
-                console.log(`[Dry Run] Would create asset: ${assetId}`);
-                idMap.set(assetId, assetId);
-                stats.assets.created++;
-                continue;
-            }
-            console.log(`Creating asset: ${assetId}`);
-            const newAsset = await targetEnv.createAssetWithId(assetId, {
-                fields: asset.fields,
-                metadata: asset.metadata,
-            });
-            await newAsset.publish(); // Ensure published so wrappers can link
-            // Update our map so subsequent calls know it exists
-            targetAssetsMap.set(assetId, newAsset);
-            idMap.set(assetId, assetId);
-            stats.assets.created++;
-        }
-        catch (error) {
-            console.error(`Failed to migrate asset ${assetId}:`, error);
-            throw error; // Fail fast
-        }
-    }
-}
-// --- Mapping Logic ---
-// Helper to get localized value (assuming 'en-US' or generic)
-function getVal(field, locale = 'en-US') {
-    if (!field)
-        return undefined;
-    return field[locale] || Object.values(field)[0];
-}
-function slugify(text) {
-    return text
-        .toString()
-        .toLowerCase()
-        .trim()
-        .replace(/\s+/g, '-') // Replace spaces with -
-        .replace(/[^\w-]+/g, '') // Remove all non-word chars
-        .replace(/--+/g, '-'); // Replace multiple - with single -
-}
-// Dependency walker for single ID mode
-function collectReferences(obj, refs = { entries: new Set(), assets: new Set() }) {
-    if (!obj || typeof obj !== 'object')
-        return refs;
-    if (Array.isArray(obj)) {
-        obj.forEach((item) => collectReferences(item, refs));
-        return refs;
-    }
-    if (obj.sys && obj.sys.type === 'Link') {
-        if (obj.sys.linkType === 'Entry') {
-            refs.entries.add(obj.sys.id);
-        }
-        else if (obj.sys.linkType === 'Asset') {
-            refs.assets.add(obj.sys.id);
-        }
-        return refs;
-    }
-    for (const key in obj) {
-        collectReferences(obj[key], refs);
-    }
-    return refs;
-}
-function getEntryReferences(entry) {
-    const refs = { entries: new Set(), assets: new Set() };
-    for (const field of Object.values(entry.fields)) {
-        const val = getVal(field);
-        collectReferences(val, refs);
-    }
-    return refs;
-}
-async function getReachableContent(rootEntries, allEntriesMap) {
-    const reachableEntries = new Set();
-    const reachableAssets = new Set();
-    const queue = [...rootEntries];
-    // Mark roots as reachable
-    for (const root of rootEntries) {
-        reachableEntries.add(root.sys.id);
-    }
-    while (queue.length > 0) {
-        const entry = queue.shift();
-        const refs = getEntryReferences(entry);
-        // Add Assets
-        for (const assetId of refs.assets) {
-            reachableAssets.add(assetId);
-        }
-        // Add Entries
-        for (const entryId of refs.entries) {
-            if (!reachableEntries.has(entryId)) {
-                reachableEntries.add(entryId);
-                const linkedEntry = allEntriesMap.get(entryId);
-                if (linkedEntry) {
-                    queue.push(linkedEntry);
-                }
-            }
-        }
-    }
-    return { entries: reachableEntries, assets: reachableAssets };
-}
-function createLink(id, linkType) {
-    return {
-        sys: {
-            type: 'Link',
-            linkType,
-            id,
-        },
-    };
-}
-function transformRichText(document) {
-    if (!document)
-        return undefined;
-    // If input is a string, wrap it in a basic Rich Text document
-    if (typeof document === 'string') {
-        return {
-            nodeType: 'document',
-            data: {},
-            content: [
-                {
-                    nodeType: 'paragraph',
-                    data: {},
-                    content: [
-                        {
-                            nodeType: 'text',
-                            value: document,
-                            marks: [],
-                            data: {},
-                        },
-                    ],
-                },
-            ],
-        };
-    }
-    if (!document.nodeType)
-        return document;
-    const newDoc = JSON.parse(JSON.stringify(document));
-    function traverse(node) {
-        if (node.data && node.data.target && node.data.target.sys) {
-            const oldId = node.data.target.sys.id;
-            if (idMap.has(oldId)) {
-                node.data.target.sys.id = idMap.get(oldId);
-            }
-        }
-        if (node.content) {
-            node.content.forEach(traverse);
-        }
-    }
-    traverse(newDoc);
-    return newDoc;
-}
-// Helper to pick best resolution image
-function getBestImage(candidates, assetsMap, sourceEntriesMap) {
-    let bestAsset = undefined;
-    let maxPixels = 0;
-    for (const item of candidates) {
-        if (!item)
-            continue;
-        let assetId = '';
-        // Resolve Entry wrappers (imageAndAltText)
-        if (item.sys.linkType === 'Entry') {
-            const entryId = item.sys.id;
-            const linkedEntry = sourceEntriesMap?.get(entryId);
-            if (linkedEntry && linkedEntry.sys.contentType.sys.id === 'imageAndAltText') {
-                const wrappedAsset = getVal(linkedEntry.fields.image);
-                if (wrappedAsset)
-                    assetId = wrappedAsset.sys.id;
-            }
-        }
-        else if (item.sys.linkType === 'Asset') {
-            assetId = item.sys.id;
-        }
-        if (assetId && assetsMap) {
-            const asset = assetsMap.get(assetId);
-            if (asset && asset.fields.file) {
-                const file = getVal(asset.fields.file);
-                if (file && file.details && file.details.image) {
-                    const pixels = (file.details.image.width || 0) * (file.details.image.height || 0);
-                    if (pixels > maxPixels) {
-                        maxPixels = pixels;
-                        // Return the Asset Link.
-                        bestAsset = createLink(assetId, 'Asset');
-                    }
-                }
-            }
-        }
-    }
-    // Fallback: if no dimensions found (e.g. SVG) or no assetsMap, return first resolvable asset
-    if (!bestAsset && candidates.length > 0) {
-        const item = candidates.find(c => c);
-        if (item) {
-            if (item.sys.linkType === 'Entry') {
-                const entryId = item.sys.id;
-                const linkedEntry = sourceEntriesMap?.get(entryId);
-                if (linkedEntry && linkedEntry.sys.contentType.sys.id === 'imageAndAltText') {
-                    const wrappedAsset = getVal(linkedEntry.fields.image);
-                    if (wrappedAsset)
-                        return createLink(wrappedAsset.sys.id, 'Asset');
-                }
-            }
-            else {
-                return item; // Assume Asset Link
-            }
-        }
-    }
-    return bestAsset ? { sys: bestAsset.sys } : undefined;
-}
-function mapEntry(entry, sourceEntriesMap, sourceAssetsMap) {
-    const contentTypeId = entry.sys.contentType.sys.id;
-    const fields = {};
-    const locale = 'en-US';
-    const set = (key, value) => {
-        if (value !== undefined)
-            fields[key] = { [locale]: value };
-    };
-    const link = (fieldVal, type = 'Entry', forceArray = false) => {
-        if (!fieldVal)
-            return undefined;
-        if (Array.isArray(fieldVal)) {
-            return fieldVal.map((item) => {
-                const oldId = item.sys.id;
-                return createLink(idMap.get(oldId) || oldId, type);
-            });
-        }
-        const oldId = fieldVal.sys.id;
-        const result = createLink(idMap.get(oldId) || oldId, type);
-        return forceArray ? [result] : result;
-    };
-    const linkVisual = (fieldVal) => {
-        if (!fieldVal)
-            return undefined;
-        const assetId = fieldVal.sys.id;
-        return createLink(getWrapperId(assetId), 'Entry');
-    };
-    const linkAsset = (fieldVal) => {
-        if (!fieldVal)
-            return undefined;
-        const assetId = fieldVal.sys.id;
-        return createLink(assetId, 'Asset');
-    };
-    // --- Pages ---
-    if (contentTypeId === 'contentPage' || contentTypeId === 'page') {
-        set('title', getVal(entry.fields.title));
-        set('slug', getVal(entry.fields.path) || getVal(entry.fields.slug));
-        set('description', getVal(entry.fields.description));
-        set('cmsLabel', getVal(entry.fields.adminLabel) || getVal(entry.fields.title));
-        // Featured Image (Direct Asset Link)
-        const socialImage = getVal(entry.fields.socialImage);
-        if (socialImage) {
-            if (socialImage.sys.linkType === 'Entry') {
-                // If it links to an entry (likely imageAndAltText), try to resolve the asset
-                const entryId = socialImage.sys.id;
-                const linkedEntry = sourceEntriesMap?.get(entryId);
-                if (linkedEntry && linkedEntry.sys.contentType.sys.id === 'imageAndAltText') {
-                    const asset = getVal(linkedEntry.fields.image);
-                    if (asset) {
-                        set('featuredImage', link(asset, 'Asset'));
-                    }
-                }
-            }
-            else {
-                set('featuredImage', link(socialImage, 'Asset'));
-            }
-        }
-        // Contents (Flatten pageSection if present? For now assume contents array is main)
-        set('content', link(getVal(entry.fields.contents), 'Entry', true));
-        set('indexed', getVal(entry.fields.indexed) ?? true);
-        set('hidden', false);
-        return { contentType: 'page', fields };
-    }
-    // --- Articles ---
-    if (contentTypeId === 'blogPost' || contentTypeId === 'resourcePost') {
-        set('title', getVal(entry.fields.title));
-        set('subtitle', getVal(entry.fields.teaserTitle));
-        set('slug', getVal(entry.fields.slug));
-        set('date', getVal(entry.fields.publishDate) || new Date().toISOString());
-        set('cmsLabel', getVal(entry.fields.title));
-        // Resolve Meta Content for Description and extra Image candidate
-        const metaContentLink = getVal(entry.fields.metaContent);
-        let metaDescription;
-        let metaImage;
-        if (metaContentLink && sourceEntriesMap) {
-            const metaEntry = sourceEntriesMap.get(metaContentLink.sys.id);
-            if (metaEntry) {
-                metaDescription = getVal(metaEntry.fields.metaDescription);
-                metaImage = getVal(metaEntry.fields.metaImage);
-            }
-        }
-        // Set Description from Meta Content if available
-        if (metaDescription) {
-            set('description', metaDescription);
-        }
-        // Hardcode Article Type to 'Blog'
-        set('__assign_blog_type', true);
-        // Author (Link to Person)
-        const author = getVal(entry.fields.author);
-        if (author) {
-            set('author', link(author, 'Entry'));
-        }
-        // Featured Image Logic: Best of featuredImage, image, thumbnail, metaImage
-        const candidateImages = [
-            getVal(entry.fields.image),
-            getVal(entry.fields.thumbnail),
-            getVal(entry.fields.featuredImage),
-            metaImage
-        ];
-        const bestImage = getBestImage(candidateImages, sourceAssetsMap, sourceEntriesMap);
-        if (bestImage) {
-            set('featuredImage', { sys: bestImage.sys });
-        }
-        // Body (Rich Text) -> Component?
-        set('__body_rich_text', getVal(entry.fields.body));
-        set('indexed', true);
-        set('hidden', false);
-        return { contentType: 'article', fields };
-    }
-    // --- Components ---
-    if (contentTypeId === 'ctaCard') {
-        // Map Card Type to Component Type
-        const cardType = getVal(entry.fields.cardType);
-        set('componentType', cardType || 'CtaCard'); // Use actual cardType value
-        set('heading', getVal(entry.fields.title));
-        set('preHeading', getVal(entry.fields.eyebrow));
-        set('postHeading', getVal(entry.fields.subtitle));
-        set('body', transformRichText(getVal(entry.fields.copy)));
-        set('cmsLabel', getVal(entry.fields.adminLabel) || 'CTA Card');
-        set('showHeading', !!getVal(entry.fields.title));
-        set('anchor', getVal(entry.fields.anchor));
-        // set('backgroundColour', getVal(entry.fields.backgroundColour));
-        // set('textColour', getVal(entry.fields.textColour));
-        const media = getVal(entry.fields.media); // Asset
-        const image = getVal(entry.fields.image); // Entry (imageAndAltText)
-        if (media) {
-            set('visual', linkVisual(media));
-        }
-        else if (image) {
-            // imageAndAltText mapped to media entry, so we link to that media entry
-            set('visual', link(image));
-        }
-        set('links', link(getVal(entry.fields.buttons), 'Entry', true));
-        return { contentType: 'component', fields };
-    }
-    if (contentTypeId === 'hero') {
-        set('componentType', 'Hero');
-        set('heading', getVal(entry.fields.title)); // RichText in source, Symbol in target?
-        // If target heading is Symbol, we might need to extract text or use 'body'.
-        // Target 'heading' is Symbol. Source 'title' is RichText.
-        // We'll put source title into 'body' if it's rich, or extract string.
-        // Let's assume 'body' for rich title.
-        set('body', transformRichText(getVal(entry.fields.title)));
-        set('cmsLabel', getVal(entry.fields.adminLabel) || 'Hero');
-        set('showHeading', false); // Since we put title in body
-        const heroImage = getVal(entry.fields.heroImage);
-        if (heroImage) {
-            set('visual', link(heroImage)); // It's an Entry (imageAndAltText)
-        }
-        return { contentType: 'component', fields };
-    }
-    if (contentTypeId === 'videoModule') {
-        set('componentType', 'Video');
-        set('heading', getVal(entry.fields.title));
-        set('cmsLabel', getVal(entry.fields.adminTitle) || 'Video');
-        set('showHeading', !!getVal(entry.fields.title));
-        set('body', transformRichText(getVal(entry.fields.copy)));
-        const videoUrl = getVal(entry.fields.videoUrl);
-        if (videoUrl) {
-            set('__external_video', {
-                url: videoUrl,
-                width: getVal(entry.fields.videoWidth),
-                title: getVal(entry.fields.title) || getVal(entry.fields.adminTitle) || 'External Video',
-            });
-        }
-        else {
-            const videoAsset = getVal(entry.fields.videoAsset);
-            if (videoAsset)
-                set('visual', linkVisual(videoAsset));
-        }
-        return { contentType: 'component', fields };
-    }
-    if (contentTypeId === 'quote') {
-        set('componentType', 'Quote');
-        set('body', transformRichText(getVal(entry.fields.copy)));
-        set('cmsLabel', getVal(entry.fields.adminLabel) || 'Quote');
-        set('showHeading', false);
-        set('heading', getVal(entry.fields.authorName));
-        set('postHeading', getVal(entry.fields.authorTitle));
-        // set('backgroundColour', getVal(entry.fields.backgroundColour));
-        // set('textColour', getVal(entry.fields.textColour));
-        const image = getVal(entry.fields.image);
-        if (image) {
-            if (image.sys.linkType === 'Asset') {
-                set('visual', linkVisual(image));
-            }
-            else {
-                // Probably imageAndAltText
-                set('visual', link(image));
-            }
-        }
-        return { contentType: 'component', fields };
-    }
-    if (contentTypeId === 'textSection') {
-        set('componentType', 'Text');
-        set('body', transformRichText(getVal(entry.fields.copy)));
-        set('cmsLabel', getVal(entry.fields.adminLabel) || 'Text Section');
-        set('showHeading', false);
-        return { contentType: 'component', fields };
-    }
-    if (contentTypeId === 'itemGrid') {
-        set('componentType', 'Logos');
-        set('heading', getVal(entry.fields.title));
-        set('cmsLabel', getVal(entry.fields.adminLabel) || 'Logos');
-        set('showHeading', !!getVal(entry.fields.title));
-        set('body', transformRichText(getVal(entry.fields.copy)));
-        set('additionalCopy', transformRichText(getVal(entry.fields.footnote)));
-        // set('backgroundColour', getVal(entry.fields.backgroundColour));
-        const items = getVal(entry.fields.items);
-        if (items && Array.isArray(items)) {
-            const otherMedia = items.map((item) => {
-                if (item.sys.linkType === 'Asset') {
-                    return linkAsset(item);
-                }
-                // 2. If it's an Entry, check if it's an 'imageAndAltText'
-                if (item.sys.linkType === 'Entry') {
-                    const entryId = item.sys.id;
-                    const linkedEntry = sourceEntriesMap?.get(entryId);
-                    if (linkedEntry && linkedEntry.sys.contentType.sys.id === 'imageAndAltText') {
-                        const asset = getVal(linkedEntry.fields.image);
-                        if (asset) {
-                            // Found the asset inside imageAndAltText, link it as a Visual
-                            return linkAsset(asset);
-                        }
-                    }
-                }
-                // 3. Fallback to standard entry link
-                return link(item);
-            });
-            set('otherMedia', otherMedia);
-        }
-        return { contentType: 'component', fields };
-    }
-    if (contentTypeId === 'imageAndAltText') {
-        // Map to 'media' Entry, not 'component'
-        // 'media' has 'name' and 'asset'
-        const name = getVal(entry.fields.adminLabel) || 'Media';
-        const asset = getVal(entry.fields.image);
-        // We are creating a 'media' entry directly here.
-        // fields: name, asset
-        fields['name'] = { [locale]: name };
-        if (asset)
-            fields['asset'] = { [locale]: { sys: createLink(asset.sys.id, 'Asset').sys } };
-        return { contentType: 'media', fields };
-    }
-    // --- Collections ---
-    if (['cards', 'carousel', 'teamMemberGrid', 'featuredPostSection'].includes(contentTypeId)) {
-        let collectionType = 'Collection';
-        if (contentTypeId === 'cards') {
-            // Map Cards Type to Collection Type
-            collectionType = getVal(entry.fields.type) || 'Card Collection';
-        }
-        else {
-            collectionType =
-                contentTypeId === 'carousel'
-                    ? 'Carousel'
-                    : contentTypeId === 'teamMemberGrid'
-                        ? 'Team Grid'
-                        : 'Featured Posts';
-        }
-        set('collectionType', collectionType);
-        set('cmsLabel', getVal(entry.fields.adminLabel) || 'Collection');
-        set('heading', getVal(entry.fields.title));
-        set('showHeading', !!getVal(entry.fields.title));
-        // Common mappings
-        // set('backgroundColour', getVal(entry.fields.backgroundColour));
-        // Type Specific Mappings
-        if (contentTypeId === 'cards') {
-            set('body', transformRichText(getVal(entry.fields.copy)));
-            set('preHeading', getVal(entry.fields.eyebrow));
-            set('postHeading', getVal(entry.fields.subtitle));
-            set('additionalCopy', transformRichText(getVal(entry.fields.footnote)));
-        }
-        if (contentTypeId === 'carousel') {
-            const media = getVal(entry.fields.media);
-            if (media)
-                set('visual', linkVisual(media));
-        }
-        const contents = getVal(entry.fields.cards) ||
-            getVal(entry.fields.items) ||
-            getVal(entry.fields.teamMembers) ||
-            getVal(entry.fields.posts) ||
-            getVal(entry.fields.images) || // Added
-            getVal(entry.fields.media); // Added
-        if (contents) {
-            set('contents', link(contents, 'Entry', true));
-        }
-        set('links', link(getVal(entry.fields.links), 'Entry', true));
-        return { contentType: 'collection', fields };
-    }
-    // --- People ---
-    if (contentTypeId === 'teamMember' ||
-        contentTypeId === 'author' ||
-        contentTypeId === 'therapist') {
-        const name = getVal(entry.fields.name);
-        set('name', name);
-        // set('cmsLabel', getVal(entry.fields.name) || getVal(entry.fields.adminLabel)); // Person has no cmsLabel
-        if (name) {
-            set('slug', slugify(name));
-        }
-        set('indexed', true);
-        set('hidden', false);
-        if (contentTypeId === 'teamMember') {
-            set('jobTitle', getVal(entry.fields.role));
-            const bylines = getVal(entry.fields.bylines);
-            let bioText = transformRichText(getVal(entry.fields.bio));
-            // Append bylines to bio if present
-            if (bylines && bylines.length > 0) {
-                // Construct a simple paragraph for bylines
-                // Since we can't easily append to RichText structure without helpers, 
-                // let's assume if we have bio, we keep it. If we have bylines, we might want to add them.
-                // For simplicity, if bio is empty, use bylines as text.
-                if (!bioText) {
-                    bioText = transformRichText(bylines.join('\n'));
-                }
-            }
-            set('bio', bioText);
-            const photo = getVal(entry.fields.photo) || getVal(entry.fields.portrait) || getVal(entry.fields.portraitImage); // therapist uses portrait
-            if (photo)
-                set('media', link(photo, 'Asset'));
-        }
-        if (contentTypeId === 'author') {
-            set('bio', transformRichText(getVal(entry.fields.bio)));
-            const image = getVal(entry.fields.image);
-            if (image)
-                set('media', link(image, 'Asset'));
-        }
-        if (contentTypeId === 'therapist') {
-            set('jobTitle', getVal(entry.fields.qualifications));
-            set('bio', transformRichText(getVal(entry.fields.bio)));
-            const portrait = getVal(entry.fields.portrait);
-            if (portrait)
-                set('media', link(portrait, 'Asset'));
-        }
-        return { contentType: 'person', fields };
-    }
-    // --- Links ---
-    if (contentTypeId === 'button') {
-        set('linkText', getVal(entry.fields.label));
-        set('name', getVal(entry.fields.adminLabel) || 'Button');
-        set('useName', false);
-        set('variant', 'button');
-        // Handle internal destination - could be array, could be Asset or Entry
-        let internalDest = getVal(entry.fields.internalDestination);
-        if (Array.isArray(internalDest)) {
-            internalDest = internalDest[0];
-        }
-        if (internalDest) {
-            // Check if it's an Asset or Entry
-            if (internalDest.sys.linkType === 'Asset') {
-                set('downloadAsset', link(internalDest, 'Asset'));
-            }
-            else {
-                set('internal', link(internalDest, 'Entry'));
-            }
-        }
-        set('external', getVal(entry.fields.externalDestination));
-        return { contentType: 'link', fields };
-    }
-    // --- External Components ---
-    if (contentTypeId === 'form') {
-        set('externalComponentType', 'form');
-        set('cmsLabel', getVal(entry.fields.name) || getVal(entry.fields.adminLabel) || 'Form');
-        set('data', { formName: getVal(entry.fields.formName) || getVal(entry.fields.name) });
-        return { contentType: 'externalComponent', fields };
-    }
-    if (contentTypeId === 'genericModule') {
-        set('externalComponentType', 'generic');
-        const codeId = getVal(entry.fields.codeId);
-        set('cmsLabel', codeId || getVal(entry.fields.adminLabel) || 'Generic Module');
-        set('data', { codeId });
-        return { contentType: 'externalComponent', fields };
-    }
-    return null;
-}
-// --- Priority Sorting ---
-function getPriority(contentTypeId) {
-    // Level 1: Leafs (Dependencies)
-    if (['author', 'teamMember', 'therapist', 'imageAndAltText', 'button'].includes(contentTypeId)) {
-        return 1;
-    }
-    // Level 2: Components
-    if (['ctaCard', 'quote', 'videoModule', 'textSection', 'hero', 'form', 'genericModule', 'itemGrid'].includes(contentTypeId)) {
-        return 2;
-    }
-    // Level 3: Collections
-    if (['cards', 'carousel', 'teamMemberGrid', 'featuredPostSection'].includes(contentTypeId)) {
-        return 3;
-    }
-    // Level 4: Roots (Pages, Articles)
-    if (['contentPage', 'page', 'blogPost', 'resourcePost'].includes(contentTypeId)) {
-        return 4;
-    }
-    // Default to last
-    return 5;
-}
-// Helper to fetch all entries with pagination (Published Only)
-async function fetchAllEntries(env, query = {}) {
-    const limit = 1000;
-    let skip = 0;
-    let allItems = [];
-    while (true) {
-        const response = await env.getPublishedEntries({ ...query, limit, skip });
-        allItems = allItems.concat(response.items);
-        skip += limit;
-        if (response.items.length < limit)
-            break;
-        console.log(`Fetched ${allItems.length} published entries so far...`);
-    }
-    return allItems;
-}
-// Helper to fetch all assets with pagination
-async function fetchAllAssets(env, query = {}, publishedOnly = true) {
-    const limit = 1000;
-    let skip = 0;
-    let allItems = [];
-    while (true) {
-        const response = await (publishedOnly
-            ? env.getPublishedAssets({ ...query, limit, skip })
-            : env.getAssets({ ...query, limit, skip }));
-        allItems = allItems.concat(response.items);
-        skip += limit;
-        if (response.items.length < limit)
-            break;
-        console.log(`Fetched ${allItems.length} ${publishedOnly ? 'published' : 'total'} assets so far...`);
-    }
-    return allItems;
-}
-// --- Main Execution ---
-async function run() {
-    console.log(`Starting migration... DRY_RUN=${DRY_RUN}`);
-    const targetAssetsMap = new Map();
-    const sourceEnv = await getEnvironment(SPACE_ID, SOURCE_ENV_ID);
-    const targetEnv = await getEnvironment(SPACE_ID, TARGET_ENV_ID);
-    // Fetch existing target assets to avoid recreation errors
-    console.log('Fetching existing target assets...');
-    const targetAssetsItems = await fetchAllAssets(targetEnv, {}, false);
-    for (const asset of targetAssetsItems) {
-        targetAssetsMap.set(asset.sys.id, asset);
-    }
-    console.log(`Found ${targetAssetsMap.size} existing target assets.`);
-    const singleId = process.argv.find((arg) => arg.startsWith('--single-id='))?.split('=')[1];
-    const scopeArg = process.argv.find((arg) => arg.startsWith('--scope='))?.split('=')[1];
-    // Pre-fetch/Ensure Blog Article Type
-    let blogTypeId = '';
-    if (!DRY_RUN) {
-        blogTypeId = await getBlogArticleTypeId(targetEnv);
-    }
-    else {
-        blogTypeId = 'article-type-blog';
-    }
-    // 1. Fetch ALL Published Entries and Assets from Source
-    console.log('Fetching ALL published entries from source...');
-    const allSourceEntries = await fetchAllEntries(sourceEnv);
-    const allSourceAssets = await fetchAllAssets(sourceEnv);
-    const sourceEntriesMap = new Map();
-    for (const entry of allSourceEntries) {
-        sourceEntriesMap.set(entry.sys.id, entry);
-    }
-    const sourceAssetsMap = new Map();
-    for (const asset of allSourceAssets) {
-        sourceAssetsMap.set(asset.sys.id, asset);
-    }
-    // 2. Determine Root Entries
-    let rootEntries = [];
-    if (singleId) {
-        console.log(`Running in Single ID mode for: ${singleId}`);
-        const root = sourceEntriesMap.get(singleId);
-        if (root) {
-            rootEntries.push(root);
-        }
-        else {
-            console.warn(`Single ID ${singleId} not found in published entries.`);
-        }
-    }
-    else {
-        // Default roots: Pages and Posts
-        rootEntries = allSourceEntries.filter(entry => ['contentPage', 'page', 'blogPost', 'resourcePost'].includes(entry.sys.contentType.sys.id));
-        console.log(`Found ${rootEntries.length} root entries (Pages/Posts).`);
-    }
-    // 3. Calculate Reachable Content
-    console.log('Calculating reachable content...');
-    const reachable = await getReachableContent(rootEntries, sourceEntriesMap);
-    console.log(`Reachable: ${reachable.entries.size} entries, ${reachable.assets.size} assets.`);
-    // 4. Filter Source Items
-    const sourceEntriesItems = allSourceEntries.filter(e => reachable.entries.has(e.sys.id));
-    const sourceAssetsItems = allSourceAssets.filter(a => reachable.assets.has(a.sys.id));
-    // Sort by priority
-    sourceEntriesItems.sort((a, b) => {
-        return getPriority(a.sys.contentType.sys.id) - getPriority(b.sys.contentType.sys.id);
-    });
-    // 5. Migrate Assets
-    await migrateAssets(sourceAssetsItems, targetEnv, targetAssetsMap);
-    // 6. Process Entries
-    console.log(`Processing ${sourceEntriesItems.length} entries.`);
-    console.log('\n--- Processing Entries (Phase 1: Dependencies) ---');
-    for (const entry of sourceEntriesItems) {
-        if (getPriority(entry.sys.contentType.sys.id) !== 1)
-            continue;
-        await processEntry(entry, targetEnv, blogTypeId, sourceEntriesMap);
-    }
-    console.log('\n--- Processing Entries (Phase 2a: Content) ---');
-    for (const entry of sourceEntriesItems) {
-        const priority = getPriority(entry.sys.contentType.sys.id);
-        if (priority === 1 || priority === 4)
-            continue;
-        await processEntry(entry, targetEnv, blogTypeId, sourceEntriesMap);
-    }
-    console.log('\n--- Processing Entries (Phase 2b: Pages & Articles Sequential) ---');
-    for (const entry of sourceEntriesItems) {
-        if (getPriority(entry.sys.contentType.sys.id) !== 4)
-            continue;
-        const type = entry.sys.contentType.sys.id;
-        const isArticle = ['blogPost', 'resourcePost'].includes(type);
-        const isPage = ['contentPage', 'page'].includes(type);
-        if (scopeArg === 'articles' && !isArticle)
-            continue;
-        if (scopeArg === 'pages' && !isPage)
-            continue;
-        // Process sequentially with delay
-        await processEntry(entry, targetEnv, blogTypeId, sourceEntriesMap);
-        await new Promise((resolve) => setTimeout(resolve, 500));
-    }
-    async function processEntry(entry, targetEnv, blogTypeId, sourceEntriesMap) {
-        // Skip if not in our target list
-        if (![
-            'contentPage',
-            'page', // Added
-            'blogPost',
-            'resourcePost', // Added
-            'ctaCard',
-            'cards',
-            'carousel',
-            'itemGrid', // Added
-            'teamMemberGrid', // Added
-            'featuredPostSection', // Added
-            'quote',
-            'videoModule',
-            'hero', // Added
-            'textSection', // Added
-            'button',
-            'imageAndAltText',
-            'teamMember',
-            'author',
-            'therapist',
-            'form',
-            'genericModule',
-        ].includes(entry.sys.contentType.sys.id)) {
-            return;
-        }
-        const mapped = mapEntry(entry, sourceEntriesMap, targetAssetsMap);
-        if (!mapped) {
-            console.log(`Skipping ${entry.sys.id} (${entry.sys.contentType.sys.id}) - No mapping`);
-            return;
-        }
-        const newId = entry.sys.id;
-        idMap.set(entry.sys.id, newId);
-        // Ensure types are valid
-        if (mapped.contentType === 'component' && mapped.fields.componentType) {
-            await ensureValidValue(targetEnv, 'component', 'componentType', mapped.fields.componentType['en-US']);
-        }
-        if (mapped.contentType === 'collection' && mapped.fields.collectionType) {
-            await ensureValidValue(targetEnv, 'collection', 'collectionType', mapped.fields.collectionType['en-US']);
-        }
-        if (mapped.contentType === 'externalComponent' && mapped.fields.externalComponentType) {
-            await ensureValidValue(targetEnv, 'externalComponent', 'externalComponentType', mapped.fields.externalComponentType['en-US']);
-        }
-        // --- Special Handling: Create External Video for Video Components ---
-        if (mapped.fields.__external_video) {
-            const extVideoData = mapped.fields.__external_video['en-US'];
-            const extVideoId = `${newId}-ext-video`;
-            const extVideoEntry = {
-                name: { 'en-US': extVideoData.title },
-                url: { 'en-US': extVideoData.url },
-                width: extVideoData.width ? { 'en-US': extVideoData.width } : undefined,
-            };
-            if (DRY_RUN) {
-                console.log(`[Dry Run] Would create External Video ${extVideoId}`);
-            }
-            else {
-                await updateEntryWithRetry(targetEnv, extVideoId, 'externalVideo', extVideoEntry);
-            }
-            mapped.fields.visual = { 'en-US': { sys: createLink(extVideoId, 'Entry').sys } };
-            delete mapped.fields.__external_video;
-        }
-        // ------------------------------------------------------------
-        // --- Special Handling: Create Body Component for Articles ---
-        if (mapped.fields.__body_rich_text) {
-            const bodyId = `${newId}-body`;
-            const bodyComponent = {
-                componentType: { 'en-US': 'Blog rich text' },
-                cmsLabel: { 'en-US': `Body for ${newId}` },
-                showHeading: { 'en-US': false },
-                body: mapped.fields.__body_rich_text,
-            };
-            if (DRY_RUN) {
-                console.log(`[Dry Run] Would create Body Component ${bodyId}`);
-            }
-            else {
-                await updateEntryWithRetry(targetEnv, bodyId, 'component', bodyComponent);
-            }
-            mapped.fields.content = { 'en-US': [{ sys: createLink(bodyId, 'Entry').sys }] };
-            delete mapped.fields.__body_rich_text;
-        }
-        // Assign Blog Article Type
-        if (mapped.fields.__assign_blog_type) {
-            if (blogTypeId) {
-                mapped.fields.articleType = { 'en-US': { sys: createLink(blogTypeId, 'Entry').sys } };
-            }
-            delete mapped.fields.__assign_blog_type;
-        }
-        // ------------------------------------------------------------
-        // Ensure visual wrappers
-        for (const [key, val] of Object.entries(mapped.fields)) {
-            if (key === 'visual') {
-                const linkObj = val['en-US'];
-                if (linkObj && linkObj.sys.linkType === 'Entry' && linkObj.sys.id.startsWith('visual-')) {
-                    const wrapperId = linkObj.sys.id;
-                    const assetId = wrapperId.replace('visual-', '');
-                    await ensureWrapperEntry(targetEnv, assetId, `Wrapper for ${assetId}`, targetAssetsMap);
-                }
-            }
-        }
-        if (DRY_RUN) {
-            console.log(`[Dry Run] Would create ${mapped.contentType} (${newId}) from ${entry.sys.contentType.sys.id}`);
-            stats.entries.created++;
-            return;
-        }
-        try {
-            await updateEntryWithRetry(targetEnv, newId, mapped.contentType, mapped.fields);
-            stats.entries.created++;
-        }
-        catch (error) {
-            console.error(`Failed to create/update entry ${newId}:`, error);
-            stats.entries.errors++;
-        }
-    }
-    console.log(JSON.stringify(stats, null, 2));
-}
-run().catch(console.error);
-//# sourceMappingURL=migrate-brightline.js.map