ferrflow 5.7.0

Universal semantic versioning for monorepos and classic repos
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! Declarative publish targets. Each [`PublisherConfig`] kind has a
//! corresponding executor that takes a [`PublishContext`] and returns
//! a [`PublishOutcome`]. Kinds whose executor isn't shipped yet
//! gracefully degrade to a `dry-run only` preview so users can declare
//! their full publishing plan in config today even if half of it
//! doesn't run yet.
//!
//! See RFC #571 + foundation PR #572. v1 ships Cargo only; npm/docker/
//! helm/asset/webhook land in follow-up PRs.

use anyhow::Result;
use std::collections::BTreeMap;
use std::path::Path;

use crate::config::{PublisherConfig, RegistryConfig};

pub mod cargo;
pub mod docker;
pub mod github_release_asset;
pub mod helm;
pub mod npm;
pub mod webhook;

/// Inputs threaded into every publisher invocation. References the
/// release context that the post-publish phase already has on hand —
/// no need to clone fields just to feed a publisher.
#[allow(dead_code)]
pub struct PublishContext<'a> {
    pub package_name: &'a str,
    /// Absolute on-disk path to the package root.
    pub package_path: &'a Path,
    pub new_version: &'a str,
    /// Full git tag created for this package (`my-pkg@v1.2.3`). Some
    /// publishers (github-release-asset, webhook) use it; cargo
    /// doesn't — but threading it through every kind uniformly avoids
    /// reshaping the dispatcher when later kinds land.
    pub tag: &'a str,
    pub registries: &'a BTreeMap<String, RegistryConfig>,
    /// True when the parent `ferrflow release` call is a dry run.
    /// Publishers should emit their preview line and skip side
    /// effects.
    pub dry_run: bool,
    /// Reserved for chatty per-publisher tracing once executors grow
    /// retry / probe steps; cargo v1 doesn't honor it yet.
    pub verbose: bool,
}

/// Result of one publisher invocation. The dispatcher renders these
/// uniformly so users see a consistent log shape across every kind.
#[derive(Debug)]
pub enum PublishOutcome {
    /// Successful publish. Optional URL surfaces in the step summary.
    Published { url: Option<String> },
    /// Target was already at the requested state — idempotent skip
    /// (e.g. cargo crate version already on the registry, npm
    /// version already published). Always preferable to surfacing
    /// a generic error.
    Skipped { reason: String },
    /// Dry-run pass: nothing happened, only the preview line was
    /// printed by the caller.
    DryRun,
}

/// Dispatch one publisher entry to its executor.
pub fn run(p: &PublisherConfig, ctx: &PublishContext<'_>) -> Result<PublishOutcome> {
    match p {
        PublisherConfig::Cargo {
            registry,
            allow_dirty,
            no_verify,
        } => cargo::run(registry.as_deref(), *allow_dirty, *no_verify, ctx),
        PublisherConfig::Npm {
            registry,
            tag,
            access,
        } => npm::run(registry.as_deref(), tag.as_deref(), access.as_deref(), ctx),
        PublisherConfig::Docker {
            image,
            tags,
            platforms,
            context,
            dockerfile,
            sign,
        } => docker::run(image, tags, platforms, context, dockerfile, *sign, ctx),
        PublisherConfig::Helm { chart, registry } => helm::run(chart, registry, ctx),
        PublisherConfig::GithubReleaseAsset { path, display_name } => {
            github_release_asset::run(path, display_name.as_deref(), ctx)
        }
        PublisherConfig::Webhook { url, body, headers } => {
            webhook::run(url, body.as_ref(), headers, ctx)
        }
    }
}