@pnpm/plugin-commands-rebuild/lib/recursive.js

Commands for rebuilding dependencies

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.recursiveRebuild = recursiveRebuild;
const assert_1 = __importDefault(require("assert"));
const util_1 = __importDefault(require("util"));
const cli_utils_1 = require("@pnpm/cli-utils");
const config_1 = require("@pnpm/config");
const logger_1 = require("@pnpm/logger");
const sort_packages_1 = require("@pnpm/sort-packages");
const store_connection_manager_1 = require("@pnpm/store-connection-manager");
const mem_1 = __importDefault(require("mem"));
const p_limit_1 = __importDefault(require("p-limit"));
const implementation_1 = require("./implementation");
async function recursiveRebuild(allProjects, params, opts) {
    if (allProjects.length === 0) {
        // It might make sense to throw an exception in this case
        return;
    }
    const pkgs = Object.values(opts.selectedProjectsGraph).map((wsPkg) => wsPkg.package);
    if (pkgs.length === 0) {
        return;
    }
    const manifestsByPath = {};
    for (const { rootDir, manifest, writeProjectManifest } of pkgs) {
        manifestsByPath[rootDir] = { manifest, writeProjectManifest };
    }
    const throwOnFail = cli_utils_1.throwOnCommandFail.bind(null, 'pnpm recursive rebuild');
    const chunks = opts.sort !== false
        ? (0, sort_packages_1.sortPackages)(opts.selectedProjectsGraph)
        : [Object.keys(opts.selectedProjectsGraph).sort()];
    const store = await (0, store_connection_manager_1.createOrConnectStoreController)(opts);
    const rebuildOpts = Object.assign(opts, {
        ownLifecycleHooksStdio: 'pipe',
        pruneLockfileImporters: ((opts.ignoredPackages == null) || opts.ignoredPackages.size === 0) &&
            pkgs.length === allProjects.length,
        storeController: store.ctrl,
        storeDir: store.dir,
    });
    const result = {};
    const memReadLocalConfig = (0, mem_1.default)(config_1.readLocalConfig);
    async function getImporters() {
        const importers = [];
        await Promise.all(chunks.map(async (prefixes, buildIndex) => {
            if (opts.ignoredPackages != null) {
                prefixes = prefixes.filter((prefix) => !opts.ignoredPackages.has(prefix));
            }
            return Promise.all(prefixes.map(async (prefix) => {
                importers.push({
                    buildIndex,
                    manifest: manifestsByPath[prefix].manifest,
                    rootDir: prefix,
                });
            }));
        }));
        return importers;
    }
    const rebuild = (params.length === 0
        ? implementation_1.rebuildProjects
        : (importers, opts) => (0, implementation_1.rebuildSelectedPkgs)(importers, params, opts) // eslint-disable-line
    );
    if (opts.lockfileDir) {
        const importers = await getImporters();
        await rebuild(importers, {
            ...rebuildOpts,
            pending: opts.pending === true,
        });
        return;
    }
    const limitRebuild = (0, p_limit_1.default)((0, config_1.getWorkspaceConcurrency)(opts.workspaceConcurrency));
    for (const chunk of chunks) {
        // eslint-disable-next-line no-await-in-loop
        await Promise.all(chunk.map(async (rootDir) => limitRebuild(async () => {
            try {
                if (opts.ignoredPackages?.has(rootDir)) {
                    return;
                }
                result[rootDir] = { status: 'running' };
                const localConfig = await memReadLocalConfig(rootDir);
                await rebuild([
                    {
                        buildIndex: 0,
                        manifest: manifestsByPath[rootDir].manifest,
                        rootDir,
                    },
                ], {
                    ...rebuildOpts,
                    ...localConfig,
                    dir: rootDir,
                    pending: opts.pending === true,
                    rawConfig: {
                        ...rebuildOpts.rawConfig,
                        ...localConfig,
                    },
                });
                result[rootDir].status = 'passed';
            }
            catch (err) {
                (0, assert_1.default)(util_1.default.types.isNativeError(err));
                const errWithPrefix = Object.assign(err, {
                    prefix: rootDir,
                });
                logger_1.logger.info(errWithPrefix);
                if (!opts.bail) {
                    result[rootDir] = {
                        status: 'failure',
                        error: errWithPrefix,
                        message: err.message,
                        prefix: rootDir,
                    };
                    return;
                }
                throw err;
            }
        })));
    }
    throwOnFail(result);
}
//# sourceMappingURL=recursive.js.map