contentful-utility-suite/dist/recursivelyGatherSystemIDs.js

Suite of utilities for Contentful CMS

import contentful from "contentful-management";
const { createClient } = contentful;
export const recursivelyGatherSystemIDs = async ({ environmentID, parentIDs, space, }) => {
    const client = createClient({
        accessToken: space.managementToken,
    });
    let c_space = undefined;
    let environment = undefined;
    try {
        c_space = await client.getSpace(space.spaceID);
    }
    catch (e) {
        throw new Error("Error: Space ID was incorrect");
    }
    try {
        environment = await c_space.getEnvironment(environmentID);
    }
    catch (e) {
        throw new Error("Error: Environment ID was incorrect");
    }
    const visited = new Set();
    const allEntryIDs = new Set(parentIDs);
    const allAssetIDs = new Set();
    for (const parentID of parentIDs) {
        const { entryIDs, assetIDs } = await fetchEntryAndGetLinksRecursively(c_space, environment, parentID, visited);
        entryIDs.forEach((id) => allEntryIDs.add(id));
        assetIDs.forEach((id) => allAssetIDs.add(id));
    }
    return {
        entries: Array.from(allEntryIDs),
        assets: Array.from(allAssetIDs),
    };
};
async function fetchEntryAndGetLinksRecursively(space, environment, itemID, visited) {
    if (visited.has(itemID)) {
        return { entryIDs: [], assetIDs: [] };
    }
    visited.add(itemID);
    let item = undefined;
    let itemType = "entry";
    try {
        item = await environment.getEntry(itemID);
    }
    catch (e) {
        try {
            item = await environment.getAsset(itemID);
            itemType = "asset";
        }
        catch (e) {
            throw new Error(`A system ID you provided doesn't exist as an entry or asset: ${itemID}`);
        }
    }
    const entryIDs = [];
    const assetIDs = [];
    if (itemType === "entry") {
        const entry = item;
        Object.keys(entry.fields).forEach((fieldKey) => {
            const localizedField = entry.fields[fieldKey];
            Object.keys(localizedField).forEach((locale) => {
                const fieldValue = localizedField[locale];
                if (Array.isArray(fieldValue)) {
                    fieldValue.forEach((item) => {
                        if (item?.sys?.id && !visited.has(item.sys.id)) {
                            if (item.sys.linkType === "Entry") {
                                entryIDs.push(item.sys.id);
                            }
                            else if (item.sys.linkType === "Asset") {
                                assetIDs.push(item.sys.id);
                            }
                        }
                    });
                }
                else if (fieldValue?.sys?.id && !visited.has(fieldValue.sys.id)) {
                    if (fieldValue.sys.linkType === "Entry") {
                        entryIDs.push(fieldValue.sys.id);
                    }
                    else if (fieldValue.sys.linkType === "Asset") {
                        assetIDs.push(fieldValue.sys.id);
                    }
                }
            });
        });
        for (const linkedID of entryIDs) {
            const { entryIDs: childEntries, assetIDs: childAssets } = await fetchEntryAndGetLinksRecursively(space, environment, linkedID, visited);
            entryIDs.push(...childEntries);
            assetIDs.push(...childAssets);
        }
    }
    if (itemType === "asset") {
        const asset = item;
        assetIDs.push(asset.sys.id);
    }
    return { entryIDs, assetIDs };
}