Add check to disable publishing unstable apis by default

Signed-off-by: Ryan Bottriell <[email protected]>

Author: rydrman

crates/spk-cli/common/src/publish.rs

@@ -26,6 +26,7 @@ pub struct Publisher {
     from: Arc<storage::RepositoryHandle>,
     to: Arc<storage::RepositoryHandle>,
     skip_source_packages: bool,
+    allow_unstable_api: bool,
     force: bool,
 }
 
@@ -42,6 +43,7 @@ impl Publisher {
             from: source,
             to: destination,
             skip_source_packages: false,
+            allow_unstable_api: false,
             force: false,
         }
     }
@@ -64,6 +66,12 @@ impl Publisher {
         self
     }
 
+    /// Allow publishing packages defined with an unstable api version
+    pub fn allow_unstable_api(mut self, allow_unstable_api: bool) -> Self {
+        self.allow_unstable_api = allow_unstable_api;
+        self
+    }
+
     /// Forcefully publishing a package will overwrite an existing publish if it exists.
     pub fn force(mut self, force: bool) -> Self {
         self.force = force;
@@ -99,6 +107,12 @@ impl Publisher {
             }
             Err(err) => return Err(err.into()),
             Ok(recipe) => {
+                if !recipe.api_version().is_stable() && !self.allow_unstable_api {
+                    return Err(Error::String(format!(
+                        "Recipe has unstable api version, and allow unstable is not set: {:?}",
+                        recipe.api_version()
+                    )));
+                }
                 tracing::info!("publishing recipe: {}", recipe.ident().format_ident());
                 if self.force {
                     self.to.force_publish_recipe(&recipe).await?;
@@ -148,6 +162,12 @@ impl Publisher {
 
             tracing::debug!("   loading package: {}", build.format_ident());
             let spec = self.from.read_package(build).await?;
+            if !spec.api_version().is_stable() && !self.allow_unstable_api {
+                return Err(Error::String(format!(
+                    "Package build has unstable api version, and allow unstable is not set: {:?}",
+                    spec.api_version()
+                )));
+            }
             let components = self.from.read_components(build).await?;
             tracing::info!("publishing package: {}", spec.ident().format_ident());
             let env_spec = components.values().cloned().collect();

crates/spk-cli/group2/src/cmd_publish.rs

@@ -33,6 +33,12 @@ pub struct Publish {
     #[clap(long, short)]
     force: bool,
 
+    /// Allow publishing package specs written in unstable api versions
+    ///
+    /// The api version of a spec is the value of the `api` field within it.
+    #[clap(long)]
+    allow_unstable_api: bool,
+
     /// The local packages to publish
     ///
     /// This can be an entire package version with all builds or a
@@ -51,6 +57,7 @@ impl Run for Publish {
 
         let publisher = Publisher::new(Arc::new(source.into()), Arc::new(target.into()))
             .skip_source_packages(self.no_source)
+            .allow_unstable_api(self.allow_unstable_api)
             .force(self.force);
 
         let mut published = Vec::new();

crates/spk-schema/src/spec.rs

@@ -183,6 +183,14 @@ pub enum SpecRecipe {
     V0Package(super::v0::Spec<VersionIdent>),
 }
 
+impl SpecRecipe {
+    pub fn api_version(&self) -> RecipeApiVersion {
+        match self {
+            Self::V0Package(_) => RecipeApiVersion::V0Package,
+        }
+    }
+}
+
 impl Recipe for SpecRecipe {
     type Output = Spec;
 
@@ -279,8 +287,8 @@ impl FromYaml for SpecRecipe {
         // fairly generic, eg: 'expected struct YamlMapping'
         #[derive(Deserialize)]
         struct YamlMapping {
-            #[serde(default = "ApiVersion::default")]
-            api: ApiVersion,
+            #[serde(default = "RecipeApiVersion::default")]
+            api: RecipeApiVersion,
         }
 
         let with_version = match serde_yaml::from_str::<YamlMapping>(&yaml) {
@@ -292,7 +300,7 @@ impl FromYaml for SpecRecipe {
         };
 
         match with_version.api {
-            ApiVersion::V0Package => {
+            RecipeApiVersion::V0Package => {
                 let inner =
                     serde_yaml::from_str(&yaml).map_err(|err| SerdeError::new(yaml, err))?;
                 Ok(Self::V0Package(inner))
@@ -313,6 +321,14 @@ pub enum Spec {
     V0Package(super::v0::Spec<BuildIdent>),
 }
 
+impl Spec {
+    pub fn api_version(&self) -> PackageApiVersion {
+        match self {
+            Self::V0Package(_) => PackageApiVersion::V0Package,
+        }
+    }
+}
+
 impl Satisfy<PkgRequest> for Spec {
     fn check_satisfies_request(&self, request: &PkgRequest) -> Compatibility {
         match self {
@@ -452,8 +468,8 @@ impl FromYaml for Spec {
         // fairly generic, eg: 'expected struct YamlMapping'
         #[derive(Deserialize)]
         struct YamlMapping {
-            #[serde(default = "ApiVersion::default")]
-            api: ApiVersion,
+            #[serde(default = "PackageApiVersion::default")]
+            api: PackageApiVersion,
         }
 
         let with_version = match serde_yaml::from_str::<YamlMapping>(&yaml) {
@@ -465,7 +481,7 @@ impl FromYaml for Spec {
         };
 
         match with_version.api {
-            ApiVersion::V0Package => {
+            PackageApiVersion::V0Package => {
                 let inner =
                     serde_yaml::from_str(&yaml).map_err(|err| SerdeError::new(yaml, err))?;
                 Ok(Self::V0Package(inner))
@@ -480,14 +496,28 @@ impl AsRef<Spec> for Spec {
     }
 }
 
-#[derive(Deserialize, Serialize, Copy, Clone)]
-pub enum ApiVersion {
+#[derive(Default, Debug, Deserialize, Serialize, Copy, Clone)]
+pub enum RecipeApiVersion {
+    #[default]
+    #[serde(rename = "v0/package")]
+    V0Package,
+}
+
+impl RecipeApiVersion {
+    pub fn is_stable(&self) -> bool {
+        matches!(self, Self::V0Package)
+    }
+}
+
+#[derive(Default, Debug, Deserialize, Serialize, Copy, Clone)]
+pub enum PackageApiVersion {
+    #[default]
     #[serde(rename = "v0/package")]
     V0Package,
 }
 
-impl Default for ApiVersion {
-    fn default() -> Self {
-        Self::V0Package
+impl PackageApiVersion {
+    pub fn is_stable(&self) -> bool {
+        matches!(self, Self::V0Package)
     }
 }