versionary 0.22.0 → 0.23.1

package/README.md

@@ -157,6 +157,32 @@ For a quick trial, use:
   - per-package `package-name` can override release identity (labels + tag base)
   - per-package `changelog-file` writes package release notes to
     `<package-path>/<changelog-file>`
+  - per-package `follows` declares an asymmetric version link to one or more
+    source packages: when any source bumps, the follower releases too, with
+    bump = `max(own bump, max(source bumps))`. The follower's changelog gets a
+    `### Dependencies` section listing the followed sources. Use it when one
+    package bundles another's artifact (e.g. an editor extension that ships
+    the CLI binary). Cycles, self-references, unknown source paths, and
+    combining `follows` with `monorepo-mode: "fixed"` are config errors.
+    `follows` is non-transitive: A follows B does not imply A follows what B
+    follows.
+
+```jsonc
+// Editor extension that bundles the root CLI artifact
+{
+  "version": 1,
+  "release-type": "rust",
+  "monorepo-mode": "independent",
+  "packages": {
+    ".": { "exclude-paths": ["editors"] },
+    "editors/code": {
+      "release-type": "node",
+      "package-name": "panache-code",
+      "follows": ["."]
+    }
+  }
+}
+```
 
 Rust strategy examples:
 

package/dist/config/schema.d.ts

@@ -53,6 +53,7 @@ export declare const configSchema: z.ZodObject<{
             jsonpath: z.ZodOptional<z.ZodString>;
             pattern: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        follows: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type ConfigSchema = z.infer<typeof configSchema>;

package/dist/config/schema.js

@@ -60,6 +60,7 @@ const packageSchema = zod_1.z
     "changelog-format": zod_1.z.enum(["markdown-changelog", "r-news"]).optional(),
     "exclude-paths": zod_1.z.array(zod_1.z.string()).optional(),
     "extra-files": zod_1.z.array(artifactRuleSchema).optional(),
+    follows: zod_1.z.array(zod_1.z.string().min(1)).optional(),
 })
     .strict();
 exports.configSchema = zod_1.z
@@ -85,4 +86,88 @@ exports.configSchema = zod_1.z
     "release-type": zod_1.z.string().optional(),
     packages: zod_1.z.record(zod_1.z.string().min(1), packageSchema).optional(),
 })
-    .strict();
+    .strict()
+    .superRefine((value, ctx) => {
+    const packages = value.packages;
+    if (!packages) {
+        return;
+    }
+    const knownPaths = new Set(Object.keys(packages));
+    const followsByPath = new Map();
+    for (const [packagePath, packageConfig] of Object.entries(packages)) {
+        const follows = packageConfig.follows;
+        if (!follows || follows.length === 0) {
+            continue;
+        }
+        followsByPath.set(packagePath, follows);
+        for (const sourcePath of follows) {
+            if (sourcePath === packagePath) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Package "${packagePath}" cannot follow itself.`,
+                    path: ["packages", packagePath, "follows"],
+                });
+                continue;
+            }
+            if (!knownPaths.has(sourcePath)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Package "${packagePath}" follows unknown package "${sourcePath}".`,
+                    path: ["packages", packagePath, "follows"],
+                });
+            }
+        }
+    }
+    if (followsByPath.size > 0 && value["monorepo-mode"] === "fixed") {
+        for (const followerPath of followsByPath.keys()) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: 'Package "follows" cannot be combined with monorepo-mode "fixed" (fixed mode already pins all package versions together).',
+                path: ["packages", followerPath, "follows"],
+            });
+        }
+    }
+    const reportedCycles = new Set();
+    const findCycleFrom = (start) => {
+        const trail = [];
+        const visit = (node) => {
+            const trailIndex = trail.indexOf(node);
+            if (trailIndex !== -1) {
+                return [...trail.slice(trailIndex), node];
+            }
+            const sources = followsByPath.get(node);
+            if (!sources || sources.length === 0) {
+                return null;
+            }
+            trail.push(node);
+            for (const source of sources) {
+                if (!knownPaths.has(source)) {
+                    continue;
+                }
+                const cycle = visit(source);
+                if (cycle) {
+                    return cycle;
+                }
+            }
+            trail.pop();
+            return null;
+        };
+        return visit(start);
+    };
+    for (const followerPath of followsByPath.keys()) {
+        const cycle = findCycleFrom(followerPath);
+        if (!cycle) {
+            continue;
+        }
+        const key = [...cycle].sort().join("->");
+        if (reportedCycles.has(key)) {
+            continue;
+        }
+        reportedCycles.add(key);
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Package "follows" cycle detected: ${cycle.join(" -> ")}.`,
+            path: ["packages", cycle[0] ?? followerPath, "follows"],
+        });
+    }
+});

package/dist/release/changelog.d.ts

@@ -30,6 +30,10 @@ export declare function renderPackageChangelogSection(input: {
     commits: ParsedCommit[];
     tagPrefix: string;
     cwd?: string;
+    dependencies?: Array<{
+        name: string;
+        version: string;
+    }>;
 }): string;
 export declare function prependChangelog(cwd: string, changelogFile: string, section: string, format?: VersionaryChangelogFormat): void;
 export declare function renderRNewsReleaseNotes(input: {

package/dist/release/changelog.js

@@ -257,6 +257,9 @@ function renderPackageChangelogSection(input) {
     if (grouped.reverts.length > 0) {
         sections.push("### Reverts", ...grouped.reverts, "");
     }
+    if (input.dependencies && input.dependencies.length > 0) {
+        sections.push("### Dependencies", ...input.dependencies.map((dependency) => `- updated ${dependency.name} to v${dependency.version}`), "");
+    }
     return [header, "", ...sections].join("\n");
 }
 function prependChangelog(cwd, changelogFile, section, format = "markdown-changelog") {

package/dist/release/plan.d.ts

@@ -18,7 +18,7 @@ export interface ReleasePlan {
         releaseType: ReleaseType;
         currentVersion: string;
         nextVersion: string | null;
-        bumpReason?: "direct" | "dependency-propagation";
+        bumpReason?: "direct" | "dependency-propagation" | "follows";
         dependencySourcePaths?: string[];
         commits: ParsedCommit[];
     }>;

package/dist/release/plan.js

@@ -98,6 +98,8 @@ function createReleasePlan(cwd = process.cwd()) {
             releaseType: null,
             currentVersion: explicitPackagePlans[0]?.currentVersion ?? "0.0.0",
             nextVersion: null,
+            bumpReason: undefined,
+            dependencySourcePaths: undefined,
             commits: [],
             parsedCommits: [],
             resolvedVersionFile: versionFile,
@@ -171,7 +173,7 @@ function createReleasePlan(cwd = process.cwd()) {
             }
         }
     }
-    const adjustedPackages = packagePlans.map((pkgPlan) => {
+    const propagatedPackages = packagePlans.map((pkgPlan) => {
         const dependencySourcePaths = [
             ...(dependencySourcePathsByPackage.get(pkgPlan.path) ??
                 new Set()),
@@ -196,6 +198,47 @@ function createReleasePlan(cwd = process.cwd()) {
             dependencySourcePaths,
         };
     });
+    const followsByPath = new Map();
+    for (const [packagePath, packageConfig] of Object.entries(loaded.config.packages ?? {})) {
+        const follows = packageConfig.follows ?? [];
+        if (follows.length > 0) {
+            followsByPath.set(packagePath, follows);
+        }
+    }
+    const adjustedPackages = propagatedPackages.map((pkgPlan) => {
+        const followsSources = followsByPath.get(pkgPlan.path) ?? [];
+        const bumpingSources = followsSources
+            .map((sourcePath) => propagatedPackages.find((pkg) => pkg.path === sourcePath))
+            .filter((sourcePlan) => Boolean(sourcePlan?.nextVersion));
+        if (bumpingSources.length === 0) {
+            return pkgPlan;
+        }
+        const ownReleaseType = pkgPlan.releaseType;
+        const combinedReleaseType = (0, semver_js_1.maxReleaseType)([
+            ownReleaseType,
+            ...bumpingSources.map((sourcePlan) => sourcePlan.releaseType),
+        ]);
+        const mergedDependencySourcePaths = [
+            ...new Set([
+                ...(pkgPlan.dependencySourcePaths ?? []),
+                ...bumpingSources.map((sourcePlan) => sourcePlan.path),
+            ]),
+        ].sort((a, b) => a.localeCompare(b));
+        const sourceDrove = combinedReleaseType !== ownReleaseType ||
+            pkgPlan.bumpReason === "dependency-propagation" ||
+            pkgPlan.bumpReason === undefined;
+        const baseVersion = packageCurrentVersionByPath[pkgPlan.path] ?? pkgPlan.currentVersion;
+        const nextVersion = combinedReleaseType
+            ? (0, semver_js_1.bumpVersion)(baseVersion, combinedReleaseType, { allowStableMajor })
+            : null;
+        return {
+            ...pkgPlan,
+            releaseType: combinedReleaseType,
+            nextVersion,
+            bumpReason: sourceDrove ? "follows" : pkgPlan.bumpReason,
+            dependencySourcePaths: mergedDependencySourcePaths,
+        };
+    });
     const visiblePackages = adjustedPackages.filter((pkgPlan) => !pkgPlan.implicitRoot || hasExplicitRootPackage);
     const rootPackagePlan = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".");
     if (!rootPackagePlan) {

package/dist/release/pr.js

@@ -315,12 +315,21 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         if (!packageMetadata) {
             continue;
         }
+        const dependencySourcePaths = packagePlan.dependencySourcePaths ?? [];
+        const packageDependencies = dependencySourcePaths
+            .map((sourcePath) => plan.packages?.find((pkg) => pkg.path === sourcePath && pkg.nextVersion))
+            .filter((sourcePackage) => Boolean(sourcePackage))
+            .map((pkg) => ({
+            name: pkg.path,
+            version: pkg.nextVersion,
+        }));
         const packageSection = (0, changelog_js_1.renderPackageChangelogSection)({
             currentVersion: packagePlan.currentVersion,
             nextVersion: packagePlan.nextVersion,
             commits: packagePlan.commits,
             tagPrefix: packageMetadata.tagPrefix,
             cwd,
+            dependencies: packageDependencies,
         });
         (0, changelog_js_1.prependChangelog)(cwd, node_path_1.default.posix.join(packagePlan.path, packageChangelogFile), packageSection, "markdown-changelog");
         updatedChangelogFiles.push(node_path_1.default.posix.join(packagePlan.path, packageChangelogFile));

package/dist/release/semver.d.ts

@@ -1,4 +1,5 @@
 export type ReleaseType = "major" | "minor" | "patch" | null;
+export declare function maxReleaseType(types: ReleaseType[]): ReleaseType;
 export interface ParsedVersion {
     major: number;
     minor: number;

package/dist/release/semver.js

@@ -1,9 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxReleaseType = maxReleaseType;
 exports.parseVersion = parseVersion;
 exports.isValidVersion = isValidVersion;
 exports.compareVersions = compareVersions;
 exports.bumpVersion = bumpVersion;
+function maxReleaseType(types) {
+    if (types.includes("major")) {
+        return "major";
+    }
+    if (types.includes("minor")) {
+        return "minor";
+    }
+    if (types.includes("patch")) {
+        return "patch";
+    }
+    return null;
+}
 const SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/u;
 const COMPAT_DOTTED_PRERELEASE_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
 function normalizeVersionInput(version) {

package/dist/types/config.d.ts

@@ -15,6 +15,7 @@ export interface VersionaryPackage {
     "changelog-format"?: VersionaryChangelogFormat;
     "exclude-paths"?: string[];
     "extra-files"?: VersionaryArtifactRule[];
+    follows?: string[];
 }
 export interface VersionaryConfig {
     version: 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.22.0",
+  "version": "0.23.1",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",