@anolilab/multi-semantic-release 1.0.0

package/lib/create-inline-plugin-creator.js

@@ -0,0 +1,270 @@
+import getCommitsFiltered from "./get-commits-filtered.js";
+import { getTagHead } from "./git.js";
+import logger from "./logger.js";
+import { resolveReleaseType, updateManifestDeps } from "./update-deps.js";
+
+const { debug } = logger.withScope("msr:inlinePlugin");
+
+/**
+ * Create an inline plugin creator for a multirelease.
+ * This is caused once per multirelease and returns a function which should be called once per package within the release.
+ *
+ * @param {Package[]} packages The multi-semantic-release context.
+ * @param {MultiContext} multiContext The multi-semantic-release context.
+ * @param {Object} flags argv options
+ * @returns {Function} A function that creates an inline package.
+ *
+ * @internal
+ */
+function createInlinePluginCreator(packages, multiContext, flags) {
+    // Vars.
+    const { cwd } = multiContext;
+
+    /**
+     * Create an inline plugin for an individual package in a multirelease.
+     * This is called once per package and returns the inline plugin used for semanticRelease()
+     *
+     * @param {Package} package_ The package this function is being called on.
+     * @returns {Object} A semantic-release inline plugin containing plugin step functions.
+     *
+     * @internal
+     */
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    function createInlinePlugin(package_) {
+        // Vars.
+        const { dir, name, plugins } = package_;
+        const debugPrefix = `[${name}]`;
+
+        /**
+         * @param {object} pluginOptions Options to configure this plugin.
+         * @param {object} context The semantic-release context.
+         * @returns {Promise<void>} void
+         * @internal
+         */
+        const verifyConditions = async (pluginOptions, context) => {
+            // Restore context for plugins that does not rely on parsed opts.
+            Object.assign(context.options, context.options._pkgOptions);
+
+            // And bind the actual logger.
+            Object.assign(package_.fakeLogger, context.logger);
+
+            const result = await plugins.verifyConditions(context);
+            // eslint-disable-next-line no-param-reassign
+            package_._ready = true;
+
+            debug(debugPrefix, "verified conditions");
+
+            return result;
+        };
+
+        /**
+         * Analyze commits step.
+         * Responsible for determining the type of the next release (major, minor or patch). If multiple plugins with a analyzeCommits step are defined, the release type will be the highest one among plugins output.
+         *
+         * In multirelease: Returns "patch" if the package contains references to other local packages that have changed, or null if this package references no local packages or they have not changed.
+         * Also updates the `context.commits` setting with one returned from `getCommitsFiltered()` (which is filtered by package directory).
+         *
+         * @param {object} pluginOptions Options to configure this plugin.
+         * @param {object} context The semantic-release context.
+         * @returns {Promise<void>} Promise that resolves when done.
+         *
+         * @internal
+         */
+        const analyzeCommits = async (pluginOptions, context) => {
+            // eslint-disable-next-line no-param-reassign
+            package_._preRelease = context.branch.prerelease || null;
+            // eslint-disable-next-line no-param-reassign
+            package_._branch = context.branch.name;
+
+            // Filter commits by directory.
+            const firstParentBranch = flags.firstParent ? context.branch.name : undefined;
+
+            // Set context.commits so analyzeCommits does correct analysis.
+
+            context.commits = await getCommitsFiltered(
+                cwd,
+                dir,
+                context.lastRelease ? context.lastRelease.gitHead : undefined,
+                context.nextRelease ? context.nextRelease.gitHead : undefined,
+                firstParentBranch,
+            );
+
+            // Set lastRelease for package from context.
+            // eslint-disable-next-line no-param-reassign
+            package_._lastRelease = context.lastRelease;
+
+            // Set nextType for package from plugins.
+            // eslint-disable-next-line no-param-reassign
+            package_._nextType = await plugins.analyzeCommits(context);
+
+            // eslint-disable-next-line no-param-reassign
+            package_._analyzed = true;
+
+            // Make sure type is "patch" if the package has any deps that have been changed.
+            // eslint-disable-next-line no-param-reassign
+            package_._nextType = resolveReleaseType(package_, flags.deps.bump, flags.deps.release, [], flags.deps.prefix);
+
+            debug(debugPrefix, "commits analyzed");
+            debug(debugPrefix, `release type: ${package_._nextType}`);
+
+            // Return type.
+            return package_._nextType;
+        };
+
+        /**
+         * Generate notes step (after).
+         * Responsible for generating the content of the release note. If multiple plugins with a generateNotes step are defined, the release notes will be the result of the concatenation of each plugin output.
+         *
+         * In multirelease: Edit the H2 to insert the package name and add an upgrades section to the note.
+         * We want this at the _end_ of the release note which is why it's stored in steps-after.
+         *
+         * Should look like:
+         *
+         *     ## my-amazing-package [9.2.1](github.com/etc) 2018-12-01
+         *
+         *     ### Features
+         *
+         *     * etc
+         *
+         *     ### Dependencies
+         *
+         *     * **my-amazing-plugin:** upgraded to 1.2.3
+         *     * **my-other-plugin:** upgraded to 4.9.6
+         *
+         * @param {object} pluginOptions Options to configure this plugin.
+         * @param {object} context The semantic-release context.
+         * @returns {Promise<void>} Promise that resolves to the string
+         *
+         * @internal
+         */
+        const generateNotes = async (pluginOptions, context) => {
+            // Set nextRelease for package.
+            // eslint-disable-next-line no-param-reassign
+            package_._nextRelease = context.nextRelease;
+
+            // Wait until all todo packages are ready to generate notes.
+            // await waitForAll("_nextRelease", (p) => p._nextType);
+
+            // Vars.
+            const notes = [];
+
+            // get SHA of lastRelease if not already there (should have been done by Semantic Release...)
+            if (
+                context.lastRelease &&
+                context.lastRelease.gitTag &&
+                (!context.lastRelease.gitHead || context.lastRelease.gitHead === context.lastRelease.gitTag)
+            ) {
+                context.lastRelease.gitHead = getTagHead(context.lastRelease.gitTag, {
+                    cwd: context.cwd,
+                    env: context.env,
+                });
+            }
+
+            // Filter commits by directory (and release range)
+            const firstParentBranch = flags.firstParent ? context.branch.name : undefined;
+
+            // Set context.commits so generateNotes does correct analysis.
+
+            context.commits = await getCommitsFiltered(
+                cwd,
+                dir,
+                context.lastRelease ? context.lastRelease.gitHead : undefined,
+                context.nextRelease ? context.nextRelease.gitHead : undefined,
+                firstParentBranch,
+            );
+
+            // Get subnotes and add to list.
+            // Inject pkg name into title if it matches e.g. `# 1.0.0` or `## [1.0.1]` (as generate-release-notes does).
+            const subs = await plugins.generateNotes(context);
+            // istanbul ignore else (unnecessary to __tests__)
+            if (subs) {
+                notes.push(subs.replace(/^(#+) (\[?\d+\.\d+\.\d+\]?)/u, `$1 ${name} $2`));
+            }
+
+            // If it has upgrades add an upgrades section.
+            const upgrades = package_.localDeps.filter((d) => d._nextRelease);
+
+            if (upgrades.length > 0) {
+                notes.push(`### Dependencies`);
+
+                const bullets = upgrades.map((d) => `* **${d.name}:** upgraded to ${d._nextRelease.version}`);
+
+                notes.push(bullets.join("\n"));
+            }
+
+            debug(debugPrefix, "notes generated");
+
+            // Return the notes.
+            return notes.join("\n\n");
+        };
+
+        const prepare = async (pluginOptions, context) => {
+            updateManifestDeps(package_);
+
+            // eslint-disable-next-line no-param-reassign
+            package_._depsUpdated = true;
+
+            // Filter commits by directory.
+            const firstParentBranch = flags.firstParent ? context.branch.name : undefined;
+
+            // Set context.commits so analyzeCommits does correct analysis.
+
+            context.commits = await getCommitsFiltered(
+                cwd,
+                dir,
+                context.lastRelease ? context.lastRelease.gitHead : undefined,
+                context.nextRelease ? context.nextRelease.gitHead : undefined,
+                firstParentBranch,
+            );
+
+            const result = await plugins.prepare(context);
+
+            // eslint-disable-next-line no-param-reassign
+            package_._prepared = true;
+
+            debug(debugPrefix, "prepared");
+
+            return result;
+        };
+
+        const publish = async (pluginOptions, context) => {
+            const result = await plugins.publish(context);
+
+            // eslint-disable-next-line no-param-reassign
+            package_._published = true;
+
+            debug(debugPrefix, "published");
+
+            // istanbul ignore next
+            return result.length > 0 ? result[0] : {};
+        };
+
+        const inlinePlugin = {
+            analyzeCommits,
+            generateNotes,
+            prepare,
+            publish,
+            verifyConditions,
+        };
+
+        // Add labels for logs.
+        Object.keys(inlinePlugin).forEach((type) =>
+            // eslint-disable-next-line security/detect-object-injection
+            Reflect.defineProperty(inlinePlugin[type], "pluginName", {
+                enumerable: true,
+                value: "Inline plugin",
+                writable: false,
+            }),
+        );
+
+        debug(debugPrefix, "inlinePlugin created");
+
+        return inlinePlugin;
+    }
+
+    // Return creator function.
+    return createInlinePlugin;
+}
+
+// Exports.
+export default createInlinePluginCreator;

package/lib/get-commits-filtered.js

@@ -0,0 +1,86 @@
+// eslint-disable-next-line simple-import-sort/imports
+import { relative } from "node:path";
+
+import { execa } from "execa";
+import gitLogParser from "git-log-parser";
+
+import logger from "./logger.js";
+import { ValueError, check } from "./utils/blork.js";
+import cleanPath from "./utils/clean-path.js";
+import streamToArray from "./utils/stream-to-array.js";
+
+const { debug } = logger.withScope("msr:commitsFilter");
+
+/**
+ * Retrieve the list of commits on the current branch since the commit sha associated with the last release, or all the commits of the current branch if there is no last released version.
+ * Commits are filtered to only return those that corresponding to the package directory.
+ *
+ * This is achieved by using "-- my/dir/path" with `git log` — passing this into gitLogParser() with
+ *
+ * @param {string} cwd Absolute path of the working directory the Git repo is in.
+ * @param {string} direction Path to the target directory to filter by. Either absolute, or relative to cwd param.
+ * @param {string|void} lastRelease The SHA of the previous release (default to start of all commits if undefined)
+ * @param {string|void} nextRelease The SHA of the next release (default to HEAD if undefined)
+ * @param {string|void} firstParentBranch first-parent to determine which merges went into master
+ * @return {Promise<Array<Commit>>} The list of commits on the branch `branch` since the last release.
+ */
+async function getCommitsFiltered(cwd, direction, lastRelease, nextRelease, firstParentBranch) {
+    // Clean paths and make sure directories exist.
+    check(cwd, "cwd: directory");
+    check(direction, "dir: path");
+
+    // eslint-disable-next-line no-param-reassign
+    cwd = cleanPath(cwd);
+    // eslint-disable-next-line no-param-reassign
+    direction = cleanPath(direction, cwd);
+
+    check(direction, "dir: directory");
+    check(lastRelease, "lastRelease: alphanumeric{40}?");
+    check(nextRelease, "nextRelease: alphanumeric{40}?");
+
+    // target must be inside and different than cwd.
+    if (direction.indexOf(cwd) !== 0) {
+        throw new ValueError("dir: Must be inside cwd", direction);
+    }
+
+    if (direction === cwd) {
+        throw new ValueError("dir: Must not be equal to cwd", direction);
+    }
+
+    // Get top-level Git directory as it might be higher up the tree than cwd.
+    const root = await execa("git", ["rev-parse", "--show-toplevel"], { cwd });
+
+    // Add correct fields to gitLogParser.
+    Object.assign(gitLogParser.fields, {
+        committerDate: { key: "ci", type: Date },
+        gitTags: "d",
+        hash: "H",
+        message: "B",
+    });
+
+    // Use git-log-parser to get the commits.
+    const relpath = relative(root.stdout, direction);
+    const firstParentBranchFilter = firstParentBranch ? ["--first-parent", firstParentBranch] : [];
+    const range = (lastRelease ? `${lastRelease}..` : "") + (nextRelease || "HEAD");
+    const gitLogFilterQuery = [...firstParentBranchFilter, range, "--", relpath];
+    const stream = gitLogParser.parse({ _: gitLogFilterQuery }, { cwd, env: process.env });
+
+    const commits = await streamToArray(stream);
+
+    // Trim message and tags.
+    commits.forEach((commit) => {
+        // eslint-disable-next-line no-param-reassign
+        commit.message = commit.message.trim();
+        // eslint-disable-next-line no-param-reassign
+        commit.gitTags = commit.gitTags.trim();
+    });
+
+    debug("git log filter query: %o", gitLogFilterQuery);
+    debug("filtered commits: %O", commits);
+
+    // Return the commits.
+    return commits;
+}
+
+// Exports.
+export default getCommitsFiltered;

package/lib/get-config-multi-semrel.js

@@ -0,0 +1,78 @@
+import { createRequire } from "node:module";
+
+import { cosmiconfig } from "cosmiconfig";
+// eslint-disable-next-line you-dont-need-lodash-underscore/cast-array
+import { castArray } from "lodash-es";
+import resolveFrom from "resolve-from";
+
+import mergeConfig from "./utils/merge-config.js";
+
+const CONFIG_NAME = "multi-release";
+const CONFIG_FILES = [
+    "package.json",
+    `.${CONFIG_NAME}rc`,
+    `.${CONFIG_NAME}rc.json`,
+    `.${CONFIG_NAME}rc.yaml`,
+    `.${CONFIG_NAME}rc.yml`,
+    `.${CONFIG_NAME}rc.js`,
+    `.${CONFIG_NAME}rc.cjs`,
+    `${CONFIG_NAME}.config.js`,
+    `${CONFIG_NAME}.config.cjs`,
+];
+
+/**
+ * Get the multi semantic release configuration options for a given directory.
+ *
+ * @param {string} cwd The directory to search.
+ * @param {Object} cliOptions cli supplied options.
+ * @returns {Object} The found configuration option
+ *
+ * @internal
+ */
+export default async function getConfig(cwd, cliOptions) {
+    const { config } = (await cosmiconfig(CONFIG_NAME, { searchPlaces: CONFIG_FILES }).search(cwd)) || {};
+    const { extends: extendPaths, ...rest } = { ...config };
+
+    let options = rest;
+
+    if (extendPaths) {
+        const require = createRequire(import.meta.url);
+        // If `extends` is defined, load and merge each shareable config
+        // eslint-disable-next-line unicorn/no-array-reduce
+        const extendedOptions = castArray(extendPaths).reduce((result, extendPath) => {
+            // eslint-disable-next-line import/no-dynamic-require,security/detect-non-literal-require
+            const extendsOptions = require(resolveFrom(cwd, extendPath));
+
+            return mergeConfig(result, extendsOptions);
+        }, {});
+
+        options = mergeConfig(options, extendedOptions);
+    }
+
+    // Set default options values if not defined yet
+    options = mergeConfig(
+        {
+            branches: undefined,
+            ci: undefined,
+            debug: false,
+            deps: {
+                bump: "override",
+                prefix: "",
+                release: "patch",
+            },
+            dryRun: undefined,
+            firstParent: false,
+            ignorePackages: [],
+            ignorePrivate: true,
+            sequentialInit: false,
+            sequentialPrepare: true,
+            silent: false,
+            // eslint-disable-next-line no-template-curly-in-string
+            tagFormat: "${name}@${version}",
+        },
+        options,
+    );
+
+    // Finally merge CLI options last so they always win
+    return mergeConfig(options, cliOptions);
+}

package/lib/get-config-semantic.js

@@ -0,0 +1,36 @@
+import semanticGetConfig from "semantic-release/lib/get-config.js";
+import signale from "signale";
+import { WritableStreamBuffer } from "stream-buffers";
+
+import logger from "./logger.js";
+
+const { Signale } = signale;
+
+/**
+ * Get the release configuration options for a given directory.
+ * Unfortunately we've had to copy this over from semantic-release, creating unnecessary duplication.
+ *
+ * @param {Object} context Object containing cwd, env, and logger properties that are passed to getConfig()
+ * @param {Object} options Options object for the config.
+ * @returns {Object} Returns what semantic-release's get config returns (object with options and plugins objects).
+ *
+ * @internal
+ */
+async function getConfigSemantic({ cwd, env, stderr, stdout }, options) {
+    try {
+        // Blackhole logger (so we don't clutter output with "loaded plugin" messages).
+        const blackhole = new Signale({ stream: new WritableStreamBuffer() });
+
+        // Return semantic-release's getConfig script.
+        return await semanticGetConfig({ cwd, env, logger: blackhole, stderr, stdout }, options);
+    } catch (error) {
+        // Log error and rethrow it.
+        // istanbul ignore next (not important)
+        logger.failure(`Error in semantic-release getConfig(): %0`, error);
+        // istanbul ignore next (not important)
+        throw error;
+    }
+}
+
+// Exports.
+export default getConfigSemantic;

package/lib/get-config.js

@@ -0,0 +1,33 @@
+import { cosmiconfig } from "cosmiconfig";
+
+// Copied from get-config.js in semantic-release
+const CONFIG_NAME = "release";
+const CONFIG_FILES = [
+    "package.json",
+    `.${CONFIG_NAME}rc`,
+    `.${CONFIG_NAME}rc.json`,
+    `.${CONFIG_NAME}rc.yaml`,
+    `.${CONFIG_NAME}rc.yml`,
+    `.${CONFIG_NAME}rc.js`,
+    `.${CONFIG_NAME}rc.cjs`,
+    `${CONFIG_NAME}.config.js`,
+    `${CONFIG_NAME}.config.cjs`,
+];
+
+/**
+ * Get the release configuration options for a given directory.
+ * Unfortunately we've had to copy this over from semantic-release, creating unnecessary duplication.
+ *
+ * @param {string} cwd The directory to search.
+ * @returns {Object} The found configuration option
+ *
+ * @internal
+ */
+export default async function getConfig(cwd) {
+    // Call cosmiconfig.
+    const config = await cosmiconfig(CONFIG_NAME, { searchPlaces: CONFIG_FILES }).search(cwd);
+
+    // Return the found config or empty object.
+    // istanbul ignore next (not important).
+    return config ? config.config : {};
+}

package/lib/get-manifest.js

@@ -0,0 +1,92 @@
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+
+/**
+ * Read the content of target package.json if exists.
+ *
+ * @param {string} path file path
+ * @returns {string} file content
+ *
+ * @internal
+ */
+function readManifest(path) {
+    // Check it exists.
+    // eslint-disable-next-line security/detect-non-literal-fs-filename
+    if (!existsSync(path)) {
+        throw new ReferenceError(`package.json file not found: "${path}"`);
+    }
+
+    // Stat the file.
+    let stat;
+
+    try {
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        stat = lstatSync(path);
+    } catch {
+        // istanbul ignore next (hard to __tests__ — happens if no read access etc).
+        throw new ReferenceError(`package.json cannot be read: "${path}"`);
+    }
+
+    // Check it's a file!
+    if (!stat.isFile()) {
+        throw new ReferenceError(`package.json is not a file: "${path}"`);
+    }
+
+    // Read the file.
+    try {
+        // eslint-disable-next-line security/detect-non-literal-fs-filename
+        return readFileSync(path, "utf8");
+    } catch {
+        // istanbul ignore next (hard to __tests__ — happens if no read access etc).
+        throw new ReferenceError(`package.json cannot be read: "${path}"`);
+    }
+}
+
+/**
+ * Get the parsed contents of a package.json manifest file.
+ *
+ * @param {string} path The path to the package.json manifest file.
+ * @returns {object} The manifest file's contents.
+ *
+ * @internal
+ */
+export default function getManifest(path) {
+    // Read the file.
+    const contents = readManifest(path);
+
+    // Parse the file.
+    let manifest;
+    try {
+        manifest = JSON.parse(contents);
+    } catch {
+        throw new SyntaxError(`package.json could not be parsed: "${path}"`);
+    }
+
+    // Must be an object.
+    if (typeof manifest !== "object") {
+        throw new SyntaxError(`package.json was not an object: "${path}"`);
+    }
+
+    // Must have a name.
+    if (typeof manifest.name !== "string" || manifest.name.length === 0) {
+        throw new SyntaxError(`Package name must be non-empty string: "${path}"`);
+    }
+
+    // Check dependencies.
+    const checkDeps = (scope) => {
+        // eslint-disable-next-line no-prototype-builtins,security/detect-object-injection
+        if (manifest.hasOwnProperty(scope) && typeof manifest[scope] !== "object") {
+            throw new SyntaxError(`Package ${scope} must be object: "${path}"`);
+        }
+    };
+
+    checkDeps("dependencies");
+    checkDeps("devDependencies");
+    checkDeps("peerDependencies");
+    checkDeps("optionalDependencies");
+
+    // NOTE non-enumerable prop is skipped by JSON.stringify
+    Object.defineProperty(manifest, "__contents__", { enumerable: false, value: contents });
+
+    // Return contents.
+    return manifest;
+}

package/lib/git.js

@@ -0,0 +1,41 @@
+import { execaSync } from "execa";
+
+/**
+ * Get all the tags for a given branch.
+ *
+ * @param {String} branch The branch for which to retrieve the tags.
+ * @param {Object} [execaOptions] Options to pass to `execa`.
+ * @param {Array<String>} filters List of string to be checked inside tags.
+ *
+ * @return {Array<String>} List of git tags.
+ * @throws {Error} If the `git` command fails.
+ * @internal
+ */
+export function getTags(branch, execaOptions, filters) {
+    const { stdout } = execaSync("git", ["tag", "--merged", branch], execaOptions);
+
+    const tags = stdout
+        .split("\n")
+        .map((tag) => tag.trim())
+        .filter(Boolean);
+
+    if (!filters || filters.length === 0) {
+        return tags;
+    }
+
+    const validateSubstr = (t, f) => f.every((v) => t.includes(v));
+
+    return tags.filter((tag) => validateSubstr(tag, filters));
+}
+
+/**
+ * Get the commit sha for a given tag.
+ *
+ * @param {String} tagName Tag name for which to retrieve the commit sha.
+ * @param {Object} [execaOptions] Options to pass to `execa`.
+ *
+ * @return {String} The commit sha of the tag in parameter or `null`.
+ */
+export function getTagHead(tagName, execaOptions) {
+    return execaSync("git", ["rev-list", "-1", tagName], execaOptions).stdout;
+}