sf-decomposer/lib/core/recomposeMetadataTypes.js

Split large Salesforce metadata files into version-control-friendly pieces and rebuild deployment-ready files.

'use strict';
import { getRegistryValuesBySuffix } from '../metadata/getRegistryValuesBySuffix.js';
import { parseManifest } from '../metadata/parseManifest.js';
import { recomposeFileHandler } from '../service/recompose/recomposeFileHandler.js';
import { CONCURRENCY_LIMITS } from '../helpers/constants.js';
import { pLimit } from '../helpers/pLimit.js';
export async function recomposeMetadataTypes(options) {
    const { metadataTypes, postpurge, ignoreDirs, manifest, log, repoRoot } = options;
    let manifestFilter;
    let effectiveTypes;
    if (manifest) {
        manifestFilter = await parseManifest(manifest, ignoreDirs, repoRoot);
        for (const { type, member } of manifestFilter.unresolvedComponents) {
            log(`Warning: manifest component ${type}:${member} not found in local source; skipping.`);
        }
        // Stryker disable next-line ConditionalExpression, EqualityOperator
        if (metadataTypes && metadataTypes.length > 0) {
            const manifestTypes = new Set(manifestFilter.suffixes);
            effectiveTypes = metadataTypes.filter((type) => manifestTypes.has(type));
        }
        else {
            effectiveTypes = manifestFilter.suffixes;
        }
    }
    else {
        if (!metadataTypes || metadataTypes.length === 0) {
            throw Error('Either --metadata-type or --manifest must be provided.');
        }
        effectiveTypes = metadataTypes;
    }
    if (effectiveTypes.length === 0) {
        log('No metadata types to recompose after applying the manifest filter.');
        return { metadata: [] };
    }
    // Limit concurrent metadata type processing to prevent file system overload
    const limit = pLimit(CONCURRENCY_LIMITS.METADATA_TYPES);
    const processed = [];
    const tasks = effectiveTypes.map((metadataType) => limit(async () => {
        const manifestXmlPaths = manifestFilter?.parentXmlsBySuffix.get(metadataType);
        let metaAttributes;
        try {
            ({ metaAttributes } = await getRegistryValuesBySuffix(metadataType, 'recompose', ignoreDirs, repoRoot));
        }
        catch (err) {
            /* istanbul ignore if -- @preserve: preserves non-manifest behavior; unreachable via known CLI types */
            if (!manifestFilter)
                throw err;
            /* istanbul ignore next -- @preserve: getRegistryValuesBySuffix always throws Error instances */
            const message = err instanceof Error ? err.message : String(err);
            log(`Skipping ${metadataType}: ${message}`);
            return;
        }
        await recomposeFileHandler(metaAttributes, postpurge, manifestXmlPaths);
        processed.push(metadataType);
        log(`All metadata files have been recomposed for the metadata type: ${metadataType}`);
    }));
    await Promise.all(tasks);
    return {
        metadata: processed,
    };
}
//# sourceMappingURL=recomposeMetadataTypes.js.map