versionary 0.24.0 → 0.26.0

package/README.md

@@ -144,6 +144,17 @@ For a quick trial, use:
   Python source file (e.g. `src/<pkg>/__init__.py`) to update a `__version__`
   assignment instead. Refreshes `poetry.lock`/`uv.lock`/`pdm.lock` at the
   package root if present
+- `release-type` can also be an array of strategy names to compose them across
+  manifests, e.g. `["python", "rust"]` for a PyO3/maturin project: the first
+  entry is the *primary* (drives `readVersion`, `readPackageName`, and consumes
+  any `version-file` override); each *secondary* writes its default manifest
+  with the same target version. Common combinations:
+  - `["python", "rust"]` — PyO3/maturin (`pyproject.toml` + `Cargo.toml` +
+    `Cargo.lock`)
+  - `["node", "rust"]` — napi-rs (`package.json` + `Cargo.toml` + `Cargo.lock`)
+  - `["r", "rust"]` — R packages with embedded Rust crates (note: nested
+    `src/rust/Cargo.toml` layouts are not supported by the array form yet —
+    use a single strategy until per-strategy `version-file` overrides land)
 - simple/default strategy keeps `version.txt` as source of truth and does not
   update `package.json`
 - stable release branch (`release-branch`, default: `versionary/release`) so

package/dist/config/schema.d.ts

@@ -30,9 +30,9 @@ export declare const configSchema: z.ZodObject<{
     "bump-minor-pre-major": z.ZodOptional<z.ZodBoolean>;
     "allow-stable-major": z.ZodOptional<z.ZodBoolean>;
     "include-commit-authors": z.ZodOptional<z.ZodBoolean>;
-    "release-type": z.ZodOptional<z.ZodString>;
+    "release-type": z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     packages: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        "release-type": z.ZodOptional<z.ZodString>;
+        "release-type": z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
         "package-name": z.ZodOptional<z.ZodString>;
         "changelog-file": z.ZodOptional<z.ZodString>;
         "changelog-format": z.ZodOptional<z.ZodEnum<{

package/dist/config/schema.js

@@ -54,7 +54,9 @@ const artifactRuleSchema = zod_1.z
 });
 const packageSchema = zod_1.z
     .object({
-    "release-type": zod_1.z.string().optional(),
+    "release-type": zod_1.z
+        .union([zod_1.z.string().min(1), zod_1.z.array(zod_1.z.string().min(1)).min(1)])
+        .optional(),
     "package-name": zod_1.z.string().optional(),
     "changelog-file": zod_1.z.string().optional(),
     "changelog-format": zod_1.z.enum(["markdown-changelog", "r-news"]).optional(),
@@ -83,7 +85,9 @@ exports.configSchema = zod_1.z
     "bump-minor-pre-major": zod_1.z.boolean().optional(),
     "allow-stable-major": zod_1.z.boolean().optional(),
     "include-commit-authors": zod_1.z.boolean().optional(),
-    "release-type": zod_1.z.string().optional(),
+    "release-type": zod_1.z
+        .union([zod_1.z.string().min(1), zod_1.z.array(zod_1.z.string().min(1)).min(1)])
+        .optional(),
     packages: zod_1.z.record(zod_1.z.string().min(1), packageSchema).optional(),
 })
     .strict()

package/dist/strategy/composite.d.ts

@@ -0,0 +1,2 @@
+import type { VersionStrategy } from "./types.js";
+export declare function compositeVersionStrategy(strategies: readonly VersionStrategy[]): VersionStrategy;

package/dist/strategy/composite.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositeVersionStrategy = compositeVersionStrategy;
+function configForSecondary(config) {
+    if (config["version-file"] === undefined) {
+        return config;
+    }
+    const { "version-file": _omit, ...rest } = config;
+    return rest;
+}
+function dedupedSorted(values) {
+    return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function compositeVersionStrategy(strategies) {
+    if (strategies.length === 0) {
+        throw new Error("compositeVersionStrategy requires at least one strategy.");
+    }
+    if (strategies.length === 1) {
+        const only = strategies[0];
+        if (!only) {
+            throw new Error("compositeVersionStrategy requires at least one strategy.");
+        }
+        return only;
+    }
+    const primary = strategies[0];
+    const secondaries = strategies.slice(1);
+    if (!primary) {
+        throw new Error("compositeVersionStrategy requires at least one strategy.");
+    }
+    const composite = {
+        name: strategies.map((strategy) => strategy.name).join("+"),
+        getVersionFile(config) {
+            return primary.getVersionFile(config);
+        },
+        readVersion(cwd, config) {
+            return primary.readVersion(cwd, config);
+        },
+        writeVersion(cwd, config, version) {
+            const updated = [];
+            updated.push(...primary.writeVersion(cwd, config, version));
+            const secondaryConfig = configForSecondary(config);
+            for (const secondary of secondaries) {
+                updated.push(...secondary.writeVersion(cwd, secondaryConfig, version));
+            }
+            return dedupedSorted(updated);
+        },
+    };
+    if (primary.getDefaultChangelogFormat ||
+        secondaries.some((strategy) => strategy.getDefaultChangelogFormat)) {
+        composite.getDefaultChangelogFormat = () => {
+            return primary.getDefaultChangelogFormat?.() ?? "markdown-changelog";
+        };
+    }
+    if (primary.validateProject ||
+        secondaries.some((strategy) => strategy.validateProject)) {
+        composite.validateProject = (cwd, config) => {
+            const messages = [];
+            const primaryError = primary.validateProject?.(cwd, config) ?? null;
+            if (primaryError) {
+                messages.push(primaryError);
+            }
+            const secondaryConfig = configForSecondary(config);
+            for (const secondary of secondaries) {
+                const error = secondary.validateProject?.(cwd, secondaryConfig) ?? null;
+                if (error) {
+                    messages.push(error);
+                }
+            }
+            return messages.length === 0 ? null : messages.join("\n");
+        };
+    }
+    if (primary.readPackageName) {
+        composite.readPackageName = (cwd, config) => {
+            return primary.readPackageName?.(cwd, config) ?? null;
+        };
+    }
+    if (primary.propagateDependentPatchImpacts ||
+        secondaries.some((strategy) => strategy.propagateDependentPatchImpacts)) {
+        composite.propagateDependentPatchImpacts = (cwd, packages) => {
+            const impacted = [];
+            impacted.push(...(primary.propagateDependentPatchImpacts?.(cwd, packages) ?? []));
+            for (const secondary of secondaries) {
+                impacted.push(...(secondary.propagateDependentPatchImpacts?.(cwd, packages) ?? []));
+            }
+            return dedupedSorted(impacted);
+        };
+    }
+    if (primary.finalizeVersionWrites ||
+        secondaries.some((strategy) => strategy.finalizeVersionWrites)) {
+        composite.finalizeVersionWrites = (cwd, writes, context) => {
+            const updated = [];
+            updated.push(...(primary.finalizeVersionWrites?.(cwd, writes, context) ?? []));
+            for (const secondary of secondaries) {
+                updated.push(...(secondary.finalizeVersionWrites?.(cwd, writes, context) ?? []));
+            }
+            return dedupedSorted(updated);
+        };
+    }
+    return composite;
+}

package/dist/strategy/python.js

@@ -166,6 +166,67 @@ function readPyProjectFromCwd(cwd) {
     const content = node_fs_1.default.readFileSync(target, "utf8");
     return { parsed: parsePyProject(content, "pyproject.toml"), rawPath: target };
 }
+function packageNameFromParsed(parsed) {
+    const projectName = parsed.project?.name;
+    if (typeof projectName === "string" && projectName.trim().length > 0) {
+        return projectName.trim();
+    }
+    const poetryName = parsed.toolPoetry?.name;
+    if (typeof poetryName === "string" && poetryName.trim().length > 0) {
+        return poetryName.trim();
+    }
+    return null;
+}
+function normalizeModuleName(name) {
+    return name.replace(/[-.]+/gu, "_");
+}
+function findAuxiliaryInitPy(cwd, parsed) {
+    const packageName = packageNameFromParsed(parsed);
+    if (!packageName) {
+        return null;
+    }
+    const moduleName = normalizeModuleName(packageName);
+    const candidates = [
+        node_path_1.default.join("src", moduleName, "__init__.py"),
+        node_path_1.default.join(moduleName, "__init__.py"),
+    ];
+    for (const candidate of candidates) {
+        const absolute = node_path_1.default.join(cwd, candidate);
+        if (!node_fs_1.default.existsSync(absolute)) {
+            continue;
+        }
+        const content = node_fs_1.default.readFileSync(absolute, "utf8");
+        if (SOURCE_FILE_VERSION_PATTERN.test(content)) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function tryUpdateInitPyVersion(cwd, relativePath, version) {
+    const absolute = node_path_1.default.join(cwd, relativePath);
+    const existing = node_fs_1.default.readFileSync(absolute, "utf8");
+    if (!SOURCE_FILE_VERSION_PATTERN.test(existing)) {
+        return false;
+    }
+    const updated = writeSourceFileVersion(existing, relativePath, version);
+    node_fs_1.default.writeFileSync(absolute, updated, "utf8");
+    return true;
+}
+function tryUpdatePyProjectVersion(cwd, version) {
+    const target = node_path_1.default.join(cwd, "pyproject.toml");
+    if (!node_fs_1.default.existsSync(target)) {
+        return null;
+    }
+    const content = node_fs_1.default.readFileSync(target, "utf8");
+    const parsed = parsePyProject(content, "pyproject.toml");
+    const { projectVersion, poetryVersion } = lookupPyProjectVersions(parsed);
+    if (!projectVersion && !poetryVersion) {
+        return null;
+    }
+    const updated = writePyProjectVersion(content, "pyproject.toml", version);
+    node_fs_1.default.writeFileSync(target, updated, "utf8");
+    return "pyproject.toml";
+}
 exports.pythonVersionStrategy = {
     name: "python",
     getVersionFile(config) {
@@ -209,11 +270,27 @@ exports.pythonVersionStrategy = {
             throw new Error(`Versionary requires ${versionFile} to exist.`);
         }
         const existing = node_fs_1.default.readFileSync(versionPath, "utf8");
-        const updated = isSourceFileMode(versionFile)
-            ? writeSourceFileVersion(existing, versionFile, version)
-            : writePyProjectVersion(existing, versionFile, version);
-        node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
-        return [versionFile];
+        const written = [];
+        if (isSourceFileMode(versionFile)) {
+            const updated = writeSourceFileVersion(existing, versionFile, version);
+            node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
+            written.push(versionFile);
+            const auxiliary = tryUpdatePyProjectVersion(cwd, version);
+            if (auxiliary && auxiliary !== versionFile) {
+                written.push(auxiliary);
+            }
+        }
+        else {
+            const updated = writePyProjectVersion(existing, versionFile, version);
+            node_fs_1.default.writeFileSync(versionPath, updated, "utf8");
+            written.push(versionFile);
+            const parsed = parsePyProject(updated, versionFile);
+            const initPy = findAuxiliaryInitPy(cwd, parsed);
+            if (initPy && tryUpdateInitPyVersion(cwd, initPy, version)) {
+                written.push(initPy);
+            }
+        }
+        return written;
     },
     readPackageName(cwd, _config) {
         const found = readPyProjectFromCwd(cwd);

package/dist/strategy/resolve.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listKnownReleaseTypes = listKnownReleaseTypes;
 exports.resolveVersionStrategy = resolveVersionStrategy;
+const composite_js_1 = require("./composite.js");
 const latex_js_1 = require("./latex.js");
 const node_js_1 = require("./node.js");
 const python_js_1 = require("./python.js");
@@ -19,12 +20,30 @@ const strategyRegistry = {
 function listKnownReleaseTypes() {
     return Object.keys(strategyRegistry).sort((a, b) => a.localeCompare(b));
 }
-function resolveVersionStrategy(config) {
-    const releaseType = config["release-type"] ?? "simple";
-    const strategy = strategyRegistry[releaseType];
+function resolveSingle(name) {
+    const strategy = strategyRegistry[name];
     if (!strategy) {
         const known = listKnownReleaseTypes().join(", ");
-        throw new Error(`Unsupported release-type "${releaseType}". Supported release types: ${known}.`);
+        throw new Error(`Unsupported release-type "${name}". Supported release types: ${known}.`);
     }
     return strategy;
 }
+function resolveVersionStrategy(config) {
+    const releaseType = config["release-type"] ?? "simple";
+    if (Array.isArray(releaseType)) {
+        if (releaseType.length === 0) {
+            throw new Error("release-type array must contain at least one strategy name.");
+        }
+        const seen = new Set();
+        const strategies = [];
+        for (const name of releaseType) {
+            if (seen.has(name)) {
+                throw new Error(`release-type array contains duplicate entry "${name}".`);
+            }
+            seen.add(name);
+            strategies.push(resolveSingle(name));
+        }
+        return (0, composite_js_1.compositeVersionStrategy)(strategies);
+    }
+    return resolveSingle(releaseType);
+}

package/dist/strategy/rust.js

@@ -748,6 +748,9 @@ exports.rustVersionStrategy = {
         const manifestToPath = new Map();
         for (const pkg of packages) {
             const manifest = pkg.versionFile;
+            if (node_path_1.default.posix.basename(normalizeSlashPath(manifest)) !== "Cargo.toml") {
+                continue;
+            }
             candidateManifests.push(manifest);
             manifestToPath.set(manifest, pkg.packagePath);
             if (pkg.nextVersion) {
@@ -763,6 +766,10 @@ exports.rustVersionStrategy = {
     finalizeVersionWrites(cwd, writes, _context) {
         const manifestToVersion = {};
         for (const write of writes) {
+            if (node_path_1.default.posix.basename(normalizeSlashPath(write.versionFile)) !==
+                "Cargo.toml") {
+                continue;
+            }
             manifestToVersion[write.versionFile] = write.version;
         }
         return [

package/dist/types/config.d.ts

@@ -9,7 +9,7 @@ export interface VersionaryArtifactRule {
     pattern?: string;
 }
 export interface VersionaryPackage {
-    "release-type"?: string;
+    "release-type"?: string | string[];
     "package-name"?: string;
     "changelog-file"?: string;
     "changelog-format"?: VersionaryChangelogFormat;
@@ -33,7 +33,7 @@ export interface VersionaryConfig {
     "bump-minor-pre-major"?: boolean;
     "allow-stable-major"?: boolean;
     "include-commit-authors"?: boolean;
-    "release-type"?: string;
+    "release-type"?: string | string[];
     packages?: Record<string, VersionaryPackage>;
 }
 export interface LoadedConfig {

package/package.json

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