@anolilab/multi-semantic-release 1.0.0

package/lib/update-deps.js

@@ -0,0 +1,388 @@
+import { writeFileSync } from "node:fs";
+
+import { isEqual, isObject, transform } from "lodash-es";
+import semver from "semver";
+
+import getManifest from "./get-manifest.js";
+import logger from "./logger.js";
+import { getHighestVersion, getLatestVersion } from "./utils/get-version.js";
+import recognizeFormat from "./utils/recognize-format.js";
+
+const { debug } = logger.withScope("msr:updateDeps");
+
+/**
+ * Resolve next prerelease comparing bumped tags versions with last version.
+ *
+ * @param {string|null} latestTag Last released tag from branch or null if non-existent.
+ * @param {string} lastVersion Last version released.
+ * @param {string} packagePreRelease Prerelease tag from package to-be-released.
+ * @returns {string} Next pkg version.
+ * @internal
+ */
+const _nextPreHighestVersion = (latestTag, lastVersion, packagePreRelease) => {
+    const bumpFromTags = latestTag ? semver.inc(latestTag, "prerelease", packagePreRelease) : null;
+    const bumpFromLast = semver.inc(lastVersion, "prerelease", packagePreRelease);
+
+    return bumpFromTags ? getHighestVersion(bumpFromLast, bumpFromTags) : bumpFromLast;
+};
+
+/**
+ * Resolve next prerelease special cases: highest version from tags or major/minor/patch.#
+ *
+ * @param {Array<string>} tags - if non-empty, we will use these tags as part fo the comparison
+ * @param {string} lastVersionForCurrentMultiRelease Last package version released from multi-semantic-release
+ * @param {string} packageNextType Next type evaluated for the next package type.
+ * @param {string} packagePreRelease Package prerelease suffix.
+ * @returns {string|undefined} Next pkg version.
+ * @internal
+ */
+const _nextPreVersionCases = (tags, lastVersionForCurrentMultiRelease, packageNextType, packagePreRelease) => {
+    // Case 1: Normal release on last version and is now converted to a prerelease
+    if (!semver.prerelease(lastVersionForCurrentMultiRelease)) {
+        const { major, minor, patch } = semver.parse(lastVersionForCurrentMultiRelease);
+
+        return `${semver.inc(`${major}.${minor}.${patch}`, packageNextType || "patch")}-${packagePreRelease}.1`;
+    }
+
+    // Case 2: Validates version with tags
+    const latestTag = getLatestVersion(tags, true);
+
+    return _nextPreHighestVersion(latestTag, lastVersionForCurrentMultiRelease, packagePreRelease);
+};
+
+/**
+ * Get dependent release type by recursive scanning and updating pkg deps.
+ *
+ * @param {Package} package_ The package with local deps to check.
+ * @param {string} bumpStrategy Dependency resolution strategy: override, satisfy, inherit.
+ * @param {string} releaseStrategy Release type triggered by deps updating: patch, minor, major, inherit.
+ * @param {Package[]} ignore Packages to ignore (to prevent infinite loops).
+ * @param {string} prefix Dependency version prefix to be attached if `bumpStrategy='override'`. ^ | ~ | '' (defaults to empty string)
+ * @returns {string|undefined} Returns the highest release type if found, undefined otherwise
+ * @internal
+ */
+const getDependentRelease = (package_, bumpStrategy, releaseStrategy, ignore, prefix) => {
+    const severityOrder = ["patch", "minor", "major"];
+    const { localDeps, manifest = {} } = package_;
+    const lastVersion = package_._lastRelease && package_._lastRelease.version;
+    const { dependencies = {}, devDependencies = {}, optionalDependencies = {}, peerDependencies = {} } = manifest;
+    const scopes = [dependencies, devDependencies, peerDependencies, optionalDependencies];
+    const bumpDependency = (scope, name, nextVersion) => {
+        // eslint-disable-next-line security/detect-object-injection
+        const currentVersion = scope[name];
+
+        if (!nextVersion || !currentVersion) {
+            return false;
+        }
+
+        // eslint-disable-next-line no-use-before-define
+        const resolvedVersion = resolveNextVersion(currentVersion, nextVersion, bumpStrategy, prefix);
+
+        if (currentVersion !== resolvedVersion) {
+            // eslint-disable-next-line no-param-reassign,security/detect-object-injection
+            scope[name] = resolvedVersion;
+
+            return true;
+        }
+
+        return false;
+    };
+
+    return (
+        localDeps
+            .filter((p) => !ignore.includes(p))
+            // eslint-disable-next-line unicorn/no-array-reduce
+            .reduce((releaseType, p) => {
+                // Has changed if...
+                // 1. Any local dep package itself has changed
+                // 2. Any local dep package has local deps that have changed.
+                // eslint-disable-next-line no-use-before-define
+                const nextType = resolveReleaseType(p, bumpStrategy, releaseStrategy, [...ignore, package_], prefix);
+                const nextVersion = nextType
+                    ? // Update the nextVersion only if there is a next type to be bumped
+
+                    p._preRelease
+                        ? // eslint-disable-next-line no-use-before-define
+                        getNextPreVersion(p)
+                        : // eslint-disable-next-line no-use-before-define
+                        getNextVersion(p)
+                    : // Set the nextVersion fallback to the last local dependency package last version
+                    p._lastRelease && p._lastRelease.version;
+
+                // 3. And this change should correspond to the manifest updating rule.
+                const requireRelease = scopes
+                    // eslint-disable-next-line unicorn/no-array-reduce
+                    .reduce((result, scope) => bumpDependency(scope, p.name, nextVersion) || result, !lastVersion);
+
+                return requireRelease && severityOrder.indexOf(nextType) > severityOrder.indexOf(releaseType) ? nextType : releaseType;
+            }, undefined)
+    );
+};
+
+/**
+ * Substitute "workspace:" in currentVersion
+ * See:
+ * {@link https://yarnpkg.com/features/workspaces#publishing-workspaces}
+ * {@link https://pnpm.io/workspaces#publishing-workspace-packages}
+ *
+ * @param {string} currentVersion Current version, may start with "workspace:"
+ * @param {string} nextVersion Next version
+ * @returns {string} current version without "workspace:"
+ */
+const substituteWorkspaceVersion = (currentVersion, nextVersion) => {
+    if (currentVersion.startsWith("workspace:")) {
+        // eslint-disable-next-line regexp/optimal-quantifier-concatenation
+        const [, range, caret] = /^workspace:(([\^~*])?.*)$/u.exec(currentVersion);
+
+        return caret === range ? (caret === "*" ? nextVersion : caret + nextVersion) : range;
+    }
+
+    return currentVersion;
+};
+
+// eslint-disable-next-line no-secrets/no-secrets
+// https://gist.github.com/Yimiprod/7ee176597fef230d1451
+const difference = (object, base) =>
+    transform(object, (result, value, key) => {
+        // eslint-disable-next-line security/detect-object-injection
+        if (!isEqual(value, base[key])) {
+            // eslint-disable-next-line security/detect-object-injection,no-param-reassign
+            result[key] = isObject(value) && isObject(base[key]) ? difference(value, base[key]) : `${base[key]} → ${value}`;
+        }
+    });
+
+/**
+ * Clarify what exactly was changed in manifest file.
+ * @param {object} actualManifest manifest object
+ * @param {string} path manifest path
+ * @returns {boolean} has changed or not
+ * @internal
+ */
+const auditManifestChanges = (actualManifest, path) => {
+    const debugPrefix = `[${actualManifest.name}]`;
+    const oldManifest = getManifest(path);
+    const depScopes = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+    // eslint-disable-next-line unicorn/no-array-reduce
+    const changes = depScopes.reduce((result, scope) => {
+        // eslint-disable-next-line security/detect-object-injection
+        const diff = difference(actualManifest[scope], oldManifest[scope]);
+
+        if (Object.keys(diff).length > 0) {
+            // eslint-disable-next-line security/detect-object-injection,no-param-reassign
+            result[scope] = diff;
+        }
+
+        return result;
+    }, {});
+
+    debug(debugPrefix, "package.json path=", path);
+
+    if (Object.keys(changes).length > 0) {
+        debug(debugPrefix, "changes=", changes);
+
+        return true;
+    }
+
+    debug(debugPrefix, "no deps changes");
+
+    return false;
+};
+
+/**
+ * Resolve next package version.
+ *
+ * @param {Package} package_ Package object.
+ * @returns {string|undefined} Next pkg version.
+ * @internal
+ */
+export const getNextVersion = (package_) => {
+    const lastVersion = package_._lastRelease && package_._lastRelease.version;
+
+    return lastVersion && typeof package_._nextType === "string" ? semver.inc(lastVersion, package_._nextType) : lastVersion || "1.0.0";
+};
+
+/**
+ * Resolve the package version from a tag
+ *
+ * @param {Package} package_ Package object.
+ * @param {string} tag The tag containing the version to resolve
+ * @returns {string|null} The version of the package or null if no tag was passed
+ * @internal
+ */
+export const getVersionFromTag = (package_, tag) => {
+    if (!package_.name) {
+        return tag || null;
+    }
+
+    if (!tag) {
+        return null;
+    }
+
+    // TODO inherit semantic-release/lib/branches/get-tags.js
+    const stringMatch = tag.match(/\d.\d.\d[^+]*/u);
+    return stringMatch && stringMatch[0] && semver.valid(stringMatch[0]) ? stringMatch[0] : null;
+};
+
+/**
+ * Parse the prerelease tag from a semver version.
+ *
+ * @param {string} version Semver version in a string format.
+ * @returns {string|null} preReleaseTag Version prerelease tag or null.
+ * @internal
+ */
+export const getPreReleaseTag = (version) => {
+    const parsed = semver.parse(version);
+
+    if (!parsed) {
+        return null;
+    }
+
+    return parsed.prerelease[0] || null;
+};
+
+/**
+ * Resolve next package version on prereleases.
+ *
+ * Will resolve highest next version of either:
+ *
+ * 1. The last release for the package during this multi-release cycle
+ * 2. (if tag options provided):
+ *   a. the highest increment of the tags array provided
+ *   b. the highest increment of the gitTags for the prerelease
+ *
+ *
+ * @param {Package} package_ Package object.
+ * @returns {string|undefined} Next pkg version.
+ * @internal
+ */
+export const getNextPreVersion = (package_) => {
+    // Note: this is only set is a current multi-semantic-release released
+    const lastVersionForCurrentRelease = package_._lastRelease && package_._lastRelease.version;
+
+    const lastPreReleaseTag = getPreReleaseTag(lastVersionForCurrentRelease);
+    const isNewPreReleaseTag = lastPreReleaseTag && lastPreReleaseTag !== package_._preRelease;
+
+    return isNewPreReleaseTag || !lastVersionForCurrentRelease
+        ? `1.0.0-${package_._preRelease}.1`
+        : _nextPreVersionCases([], lastVersionForCurrentRelease, package_._nextType, package_._preRelease);
+};
+
+/**
+ * Resolve package release type taking into account the cascading dependency update.
+ *
+ * @param {Package} package_ Package object.
+ * @param {string|undefined} bumpStrategy Dependency resolution strategy: override, satisfy, inherit.
+ * @param {string|undefined} releaseStrategy Release type triggered by deps updating: patch, minor, major, inherit.
+ * @param {Package[]} ignore Packages to ignore (to prevent infinite loops).
+ * @param {string} prefix Dependency version prefix to be attached if `bumpStrategy='override'`. ^ | ~ | '' (defaults to empty string)
+ * @returns {string|undefined} Resolved release type.
+ * @internal
+ */
+export const resolveReleaseType = (package_, bumpStrategy = "override", releaseStrategy = "patch", ignore = [], prefix = "") => {
+    // NOTE This fn also updates pkg deps, so it must be invoked anyway.
+    const dependentReleaseType = getDependentRelease(package_, bumpStrategy, releaseStrategy, ignore, prefix);
+
+    // Release type found by commitAnalyzer.
+    if (package_._nextType) {
+        return package_._nextType;
+    }
+
+    if (!dependentReleaseType) {
+        return undefined;
+    }
+
+    // Define release type for dependent package if any of its deps changes.
+    // `patch`, `minor`, `major` — strictly declare the release type that occurs when any dependency is updated.
+    // `inherit` — applies the "highest" release of updated deps to the package.
+    // For example, if any dep has a breaking change, `major` release will be applied to the all dependants up the chain.
+
+    // eslint-disable-next-line no-param-reassign
+    package_._nextType = releaseStrategy === "inherit" ? dependentReleaseType : releaseStrategy;
+
+    return package_._nextType;
+};
+
+/**
+ * Resolve next version of dependency.
+ *
+ * @param {string} currentVersion Current dep version
+ * @param {string} nextVersion Next release type: patch, minor, major
+ * @param {string|undefined} bumpStrategy Resolution strategy: inherit, override, satisfy
+ * @param {string} prefix Dependency version prefix to be attached if `bumpStrategy='override'`. ^ | ~ | '' (defaults to empty string)
+ * @returns {string} Next dependency version
+ * @internal
+ */
+export const resolveNextVersion = (currentVersion, nextVersion, bumpStrategy = "override", prefix = "") => {
+    // handle cases of "workspace protocol" defined in yarn and pnpm workspace, whose version starts with "workspace:"
+    // eslint-disable-next-line no-param-reassign
+    currentVersion = substituteWorkspaceVersion(currentVersion, nextVersion);
+
+    // if strategy is ignore, return the current version
+    if (bumpStrategy === "ignore") {
+        return currentVersion;
+    }
+
+    // no change...
+    if (currentVersion === nextVersion) {
+        return currentVersion;
+    }
+
+    // Check the next pkg version against its current references.
+    // If it matches (`*` matches to any, `1.1.0` matches `1.1.x`, `1.5.0` matches to `^1.0.0` and so on)
+    // release will not be triggered, if not `override` strategy will be applied instead.
+    if ((bumpStrategy === "satisfy" || bumpStrategy === "inherit") && semver.satisfies(nextVersion, currentVersion)) {
+        return currentVersion;
+    }
+
+    // `inherit` will try to follow the current declaration version/range.
+    // `~1.0.0` + `minor` turns into `~1.1.0`, `1.x` + `major` gives `2.x`,
+    // but `1.x` + `minor` gives `1.x` so there will be no release, etc.
+    if (bumpStrategy === "inherit") {
+        const separator = ".";
+        const nextChunks = nextVersion.split(separator);
+        const currentChunks = currentVersion.split(separator);
+        // eslint-disable-next-line security/detect-object-injection
+        const resolvedChunks = currentChunks.map((chunk, index) => (nextChunks[index] ? chunk.replace(/\d+/u, nextChunks[index]) : chunk));
+
+        return resolvedChunks.join(separator);
+    }
+
+    // "override"
+    // By default next package version would be set as is for the all dependants.
+    return prefix + nextVersion;
+};
+
+/**
+ * Update pkg deps.
+ *
+ * @param {Package} package_ The package this function is being called on.
+ * @returns {undefined}
+ * @internal
+ */
+export const updateManifestDeps = (package_) => {
+    const { manifest, path } = package_;
+    const { indent, trailingWhitespace } = recognizeFormat(manifest.__contents__);
+
+    // We need to bump pkg.version for correct yarn.lock update
+    // https://github.com/qiwi/multi-semantic-release/issues/58
+    manifest.version = package_._nextRelease.version || manifest.version;
+
+    // Loop through localDeps to verify release consistency.
+    package_.localDeps.forEach((d) => {
+        // Get version of dependency.
+        const release = d._nextRelease || d._lastRelease;
+
+        // Cannot establish version.
+        if (!release || !release.version) {
+            throw new Error(`Cannot release ${package_.name} because dependency ${d.name} has not been released yet`);
+        }
+    });
+
+    if (!auditManifestChanges(manifest, path)) {
+        return;
+    }
+
+    // Write package.json back out.
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    writeFileSync(path, JSON.stringify(manifest, null, indent) + trailingWhitespace);
+};

package/lib/utils/blork.js

@@ -0,0 +1,23 @@
+import { existsSync, lstatSync } from "node:fs";
+import { Writable } from "node:stream";
+
+import { add, checker } from "blork";
+import { WritableStreamBuffer } from "stream-buffers";
+
+// Get some checkers.
+const isAbsolute = checker("absolute");
+
+// Add a directory checker.
+// eslint-disable-next-line security/detect-non-literal-fs-filename
+add("directory", (v) => isAbsolute(v) && existsSync(v) && lstatSync(v).isDirectory(), "directory that exists in the filesystem");
+
+// Add a writable stream checker.
+add(
+    "stream",
+    // istanbul ignore next (not important)
+    (v) => v instanceof Writable || v instanceof WritableStreamBuffer,
+    "instance of stream.Writable or WritableStreamBuffer",
+);
+
+// eslint-disable-next-line simple-import-sort/exports
+export { ValueError, check } from "blork";

package/lib/utils/clean-path.js

@@ -0,0 +1,24 @@
+import { isAbsolute, join, normalize } from "node:path";
+
+import { check } from "./blork.js";
+
+/**
+ * Normalize and make a path absolute, optionally using a custom CWD.
+ * Trims any trailing slashes from the path.
+ *
+ * @param {string} path The path to normalize and make absolute.
+ * @param {string} cwd=process.cwd() The CWD to prepend to the path to make it absolute.
+ * @returns {string} The absolute and normalized path.
+ *
+ * @internal
+ */
+function cleanPath(path, cwd = process.cwd()) {
+    check(path, "path: path");
+    check(cwd, "cwd: absolute");
+
+    // Normalize, absolutify, and trim trailing slashes from the path.
+    return normalize(isAbsolute(path) ? path : join(cwd, path)).replace(/[/\\]+$/u, "");
+}
+
+// Exports.
+export default cleanPath;

package/lib/utils/get-version.js

@@ -0,0 +1,37 @@
+/**
+ * Lifted and tweaked from semantic-release because we follow how they bump their packages/dependencies.
+ * https://github.com/semantic-release/semantic-release/blob/master/lib/utils.js
+ */
+
+import { gt, prerelease, rcompare } from "semver";
+
+/**
+ * HOC that applies highest/lowest semver function.
+ * @param {Function} predicate High order function to be called.
+ * @param {string|undefined} version1 Version 1 to be compared with.
+ * @param {string|undefined} version2 Version 2 to be compared with.
+ * @returns {string|undefined} Highest or lowest version.
+ * @internal
+ */
+const _selectVersionBy = (predicate, version1, version2) => {
+    if (predicate && version1 && version2) {
+        return predicate(version1, version2) ? version1 : version2;
+    }
+    return version1 || version2;
+};
+
+/**
+ * Gets highest semver function binding gt to the HOC selectVersionBy.
+ */
+export const getHighestVersion = _selectVersionBy.bind(null, gt);
+
+/**
+ * Retrieve the latest version from a list of versions.
+ * @param {array} versions Versions as string list.
+ * @param {boolean|undefined} withPrerelease Prerelease flag.
+ * @returns {string|undefined} Latest version.
+ * @internal
+ */
+export function getLatestVersion(versions, withPrerelease) {
+    return versions.filter((version) => withPrerelease || !prerelease(version)).sort(rcompare)[0];
+}

package/lib/utils/merge-config.js

@@ -0,0 +1,21 @@
+// eslint-disable-next-line you-dont-need-lodash-underscore/cast-array
+import { castArray, pickBy } from "lodash-es";
+
+const isNil = (value) => value == null;
+
+const mergeConfig = (a = {}, b = {}) => {
+    return {
+        ...a,
+        // Remove `null` and `undefined` options so they can be replaced with default ones
+        ...pickBy(b, (option) => !isNil(option)),
+        // Treat nested objects differently as otherwise we'll loose undefined keys
+        deps: {
+            ...a.deps,
+            ...pickBy(b.deps, (option) => !isNil(option)),
+        },
+        // Treat arrays differently by merging them
+        ignorePackages: [...new Set([...castArray(a.ignorePackages || []), ...castArray(b.ignorePackages || [])])],
+    };
+};
+
+export default mergeConfig;

package/lib/utils/recognize-format.js

@@ -0,0 +1,25 @@
+import detectIndent from "detect-indent";
+import { detectNewline } from "detect-newline";
+
+/**
+ * Information about the format of a file.
+ * @typedef FileFormat
+ * @property {string|number} indent Indentation characters
+ * @property {string} trailingWhitespace Trailing whitespace at the end of the file
+ */
+
+/**
+ * Detects the indentation and trailing whitespace of a file.
+ *
+ * @param {string} contents contents of the file
+ * @returns {FileFormat} Formatting of the file
+ */
+function recognizeFormat(contents) {
+    return {
+        indent: detectIndent(contents).indent,
+        trailingWhitespace: detectNewline(contents) || "",
+    };
+}
+
+// Exports.
+export default recognizeFormat;

package/lib/utils/stream-to-array.js

@@ -0,0 +1,60 @@
+/**
+ * Converts a stream to an array
+ *
+ * @param {ReadStream} stream
+ * @returns {Promise<array>}
+ */
+export default function streamToArray(stream) {
+    if (!stream.readable) {
+        return Promise.resolve([]);
+    }
+
+    // eslint-disable-next-line compat/compat
+    return new Promise((resolve, reject) => {
+        // stream is already ended
+        if (!stream.readable) {
+            resolve([]);
+
+            return;
+        }
+
+        let array = [];
+
+        function cleanup() {
+            array = null;
+
+            // eslint-disable-next-line no-use-before-define
+            stream.removeListener("data", onData);
+            // eslint-disable-next-line no-use-before-define
+            stream.removeListener("end", onEnd);
+            // eslint-disable-next-line no-use-before-define
+            stream.removeListener("error", onError);
+            // eslint-disable-next-line no-use-before-define
+            stream.removeListener("close", onClose);
+        }
+
+        function onData(document_) {
+            array.push(document_);
+        }
+
+        function onEnd() {
+            resolve(array);
+            cleanup();
+        }
+
+        function onError(error) {
+            reject(error);
+            cleanup();
+        }
+
+        function onClose() {
+            resolve(array);
+            cleanup();
+        }
+
+        stream.on("data", onData);
+        stream.on("end", onEnd);
+        stream.on("error", onEnd);
+        stream.on("close", onClose);
+    });
+}