@terascope/scripts/dist/src/helpers/packages.js

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getPublishTag = exports.getRemotePackageVersion = exports.fixDepPkgName = exports.getDocPath = exports.updatePkgJSON = exports.updatePkgInfo = exports.getPkgNames = exports.getPkgInfo = exports.findPackageByName = exports.readPackageInfo = exports.addPackageConfig = exports.isMainPackage = exports.getMainPackageInfo = exports.getJestAliases = exports.getWorkspaceNames = exports.listPackages = exports.getE2EDir = void 0;
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const fs_extra_1 = __importDefault(require("fs-extra"));
const semver_1 = __importDefault(require("semver"));
const globby_1 = __importDefault(require("globby"));
const utils_1 = require("@terascope/utils");
// @ts-expect-error (Missing types)
const query_graph_1 = __importDefault(require("@lerna/query-graph"));
const package_json_1 = __importDefault(require("package-json"));
const sort_package_json_1 = __importDefault(require("sort-package-json"));
const misc = __importStar(require("./misc"));
const i = __importStar(require("./interfaces"));
let _packages = [];
let _e2eDir;
function getE2EDir() {
    if (_e2eDir)
        return _e2eDir;
    if (fs_1.default.existsSync(path_1.default.join(misc.getRootDir(), 'e2e'))) {
        _e2eDir = path_1.default.join(misc.getRootDir(), 'e2e');
        return _e2eDir;
    }
    return undefined;
}
exports.getE2EDir = getE2EDir;
function _loadPackage(packagePath) {
    const pkgJsonPath = path_1.default.join(packagePath, 'package.json');
    if (fs_1.default.existsSync(pkgJsonPath)) {
        return readPackageInfo(packagePath);
    }
    return undefined;
}
function _resolveWorkspaces(workspaces, rootDir) {
    return workspaces
        .reduce((pkgDirs, pkgGlob) => [
        ...pkgDirs,
        ...(globby_1.default.hasMagic(pkgGlob)
            ? globby_1.default.sync(path_1.default.join(rootDir, pkgGlob), {
                onlyDirectories: true,
            })
            : [path_1.default.join(rootDir, pkgGlob)]),
    ], []);
}
function listPackages() {
    if (_packages && _packages.length)
        return _packages.slice();
    const rootPkg = misc.getRootInfo();
    if (!rootPkg.workspaces)
        return [];
    const workspaces = (Array.isArray(rootPkg.workspaces)
        ? rootPkg.workspaces
        : rootPkg.workspaces.packages).slice();
    if (!workspaces)
        return [];
    const hasE2E = workspaces.find((workspacePath) => workspacePath.includes('e2e'));
    if (!hasE2E) {
        workspaces.push('e2e');
    }
    const workspacePaths = _resolveWorkspaces(workspaces, misc.getRootDir());
    const packages = workspacePaths
        .map(_loadPackage)
        .filter((pkg) => pkg === null || pkg === void 0 ? void 0 : pkg.name);
    _packages = query_graph_1.default.toposort(packages);
    return _packages;
}
exports.listPackages = listPackages;
function getWorkspaceNames() {
    return utils_1.uniq(listPackages()
        .filter((pkg) => !('workspaces' in pkg))
        .map((pkg) => path_1.default.basename(path_1.default.dirname(pkg.dir)))
        .filter((name) => name && name !== '.'));
}
exports.getWorkspaceNames = getWorkspaceNames;
function getJestAliases() {
    const aliases = {};
    listPackages().forEach((pkg) => {
        const key = `^${pkg.name}$`;
        const mainFile = pkg.srcMain || pkg.main;
        if (!mainFile)
            return;
        aliases[key] = path_1.default.join(pkg.dir, mainFile);
    });
    return aliases;
}
exports.getJestAliases = getJestAliases;
function getMainPackageInfo() {
    return listPackages().find(isMainPackage);
}
exports.getMainPackageInfo = getMainPackageInfo;
function isMainPackage(pkgInfo) {
    return utils_1.get(pkgInfo, 'terascope.main', false);
}
exports.isMainPackage = isMainPackage;
function addPackageConfig(pkgInfo) {
    for (const _key of Object.keys(pkgInfo.terascope)) {
        const key = _key;
        if (!i.AvailablePackageConfigKeys.includes(key)) {
            throw new Error(`Unknown terascope config "${key}" found in "${pkgInfo.name}" package`);
        }
    }
}
exports.addPackageConfig = addPackageConfig;
function readPackageInfo(folderPath) {
    const dir = path_1.default.isAbsolute(folderPath)
        ? path_1.default.join(folderPath)
        : path_1.default.join(misc.getRootDir(), folderPath);
    const pkgJSONPath = path_1.default.join(dir, 'package.json');
    const pkgJSON = getSortedPkgJSON(fs_extra_1.default.readJSONSync(pkgJSONPath));
    pkgJSON.dir = dir;
    updatePkgInfo(pkgJSON);
    return pkgJSON;
}
exports.readPackageInfo = readPackageInfo;
/** A stricter version of `getPkgInfo` */
function findPackageByName(packages, name) {
    const found = packages.find((info) => info.name === name);
    if (!found) {
        throw new Error(`Unable to find package ${name}`);
    }
    return found;
}
exports.findPackageByName = findPackageByName;
function getPkgInfo(name) {
    const found = listPackages().find((info) => [info.name, info.folderName].includes(name));
    if (!found) {
        throw new Error(`Unable to find package ${name}`);
    }
    return found;
}
exports.getPkgInfo = getPkgInfo;
function getPkgNames(packages) {
    return utils_1.uniq(packages.map((pkgInfo) => pkgInfo.folderName)).sort();
}
exports.getPkgNames = getPkgNames;
function updatePkgInfo(pkgInfo) {
    if (!pkgInfo.dir) {
        throw new Error('Missing dir on package.json reference');
    }
    if (!pkgInfo.terascope)
        pkgInfo.terascope = {};
    if (pkgInfo.terascope.enableTypedoc && !fs_1.default.existsSync(path_1.default.join(pkgInfo.dir, 'tsconfig.json'))) {
        pkgInfo.terascope.enableTypedoc = false;
    }
    const rootInfo = misc.getRootInfo();
    if (!pkgInfo.private) {
        if (!pkgInfo.publishConfig) {
            pkgInfo.publishConfig = {
                access: 'public',
                registry: rootInfo.terascope.npm.registry,
            };
        }
        else {
            pkgInfo.publishConfig = Object.assign({}, {
                access: 'public',
                registry: rootInfo.terascope.npm.registry,
            }, pkgInfo.publishConfig);
        }
    }
    else {
        delete pkgInfo.publishConfig;
    }
    pkgInfo.folderName = path_1.default.basename(pkgInfo.dir);
    pkgInfo.relativeDir = path_1.default.relative(rootInfo.dir, pkgInfo.dir);
    addPackageConfig(pkgInfo);
    if (!pkgInfo.displayName) {
        pkgInfo.displayName = misc.getName(pkgInfo.folderName);
    }
    if (!pkgInfo.license) {
        pkgInfo.license = 'MIT';
    }
}
exports.updatePkgInfo = updatePkgInfo;
function updatePkgJSON(pkgInfo, log) {
    if (!utils_1.get(pkgInfo, 'terascope.root')) {
        updatePkgInfo(pkgInfo);
    }
    const pkgJSON = getSortedPkgJSON(pkgInfo);
    delete pkgJSON.folderName;
    delete pkgJSON.dir;
    delete pkgJSON.relativeDir;
    return misc.writeIfChanged(path_1.default.join(pkgInfo.dir, 'package.json'), pkgJSON, {
        log,
    });
}
exports.updatePkgJSON = updatePkgJSON;
function getSortedPkgJSON(pkgInfo) {
    return utils_1.fastCloneDeep(sort_package_json_1.default(pkgInfo));
}
function getDocPath(pkgInfo, withFileName, withExt = true) {
    const suite = pkgInfo.terascope.testSuite;
    if (suite === 'e2e') {
        const e2eDevDocs = path_1.default.join('docs/development');
        fs_extra_1.default.ensureDirSync(e2eDevDocs);
        if (withFileName) {
            return path_1.default.join(e2eDevDocs, withExt ? `${pkgInfo.folderName}.md` : pkgInfo.folderName);
        }
        return e2eDevDocs;
    }
    const docPath = path_1.default.join('docs', pkgInfo.relativeDir);
    fs_extra_1.default.ensureDirSync(docPath);
    if (withFileName) {
        return path_1.default.join(docPath, withExt ? 'overview.md' : 'overview');
    }
    return docPath;
}
exports.getDocPath = getDocPath;
function fixDepPkgName(name) {
    return utils_1.trim(name).replace(/^\*\*\//, '').trim();
}
exports.fixDepPkgName = fixDepPkgName;
async function getRemotePackageVersion(pkgInfo) {
    if (pkgInfo.private)
        return pkgInfo.version;
    const registryUrl = utils_1.get(pkgInfo, 'publishConfig.registry');
    const tag = getPublishTag(pkgInfo.version);
    try {
        const { version } = await package_json_1.default(pkgInfo.name, {
            version: tag,
            registryUrl
        });
        return version;
    }
    catch (err) {
        if (err instanceof package_json_1.default.VersionNotFoundError) {
            return pkgInfo.version;
        }
        if (err instanceof package_json_1.default.PackageNotFoundError) {
            return '0.1.0';
        }
        throw err;
    }
}
exports.getRemotePackageVersion = getRemotePackageVersion;
function getPublishTag(version) {
    const parsed = semver_1.default.parse(version);
    if (!parsed) {
        throw new Error(`Unable to publish invalid version "${version}"`);
    }
    if (parsed.prerelease.length)
        return 'prerelease';
    return 'latest';
}
exports.getPublishTag = getPublishTag;
//# sourceMappingURL=packages.js.map