Dependencies by component ref but ugh

Signed-off-by: itowlson <[email protected]>

Author: itowlson

crates/build/src/manifest.rs

@@ -70,7 +70,7 @@ pub async fn component_build_configs(manifest_file: impl AsRef<Path>) -> Result<
     let manifest = spin_manifest::manifest_from_file(&manifest_file);
     match manifest {
         Ok(mut manifest) => {
-            spin_manifest::normalize::normalize_manifest(&mut manifest);
+            spin_manifest::normalize::normalize_manifest(&mut manifest)?;
             let components = build_configs_from_manifest(&manifest);
             let deployment_targets = deployment_targets_from_manifest(&manifest);
             Ok(ManifestBuildInfo::Loadable {

crates/environments/src/loader.rs

@@ -272,6 +272,7 @@ impl spin_compose::DependencyLike for WrappedComponentDependency {
             spin_manifest::schema::v2::ComponentDependency::Package { export, .. } => export,
             spin_manifest::schema::v2::ComponentDependency::Local { export, .. } => export,
             spin_manifest::schema::v2::ComponentDependency::HTTP { export, .. } => export,
+            spin_manifest::schema::v2::ComponentDependency::AppComponent { export, .. } => export,
         }
     }
 }

crates/loader/src/local.rs

@@ -73,7 +73,7 @@ impl LocalLoader {
 
     // Load the given manifest into a LockedApp, ready for execution.
     pub(crate) async fn load_manifest(&self, mut manifest: AppManifest) -> Result<LockedApp> {
-        spin_manifest::normalize::normalize_manifest(&mut manifest);
+        spin_manifest::normalize::normalize_manifest(&mut manifest)?;
 
         manifest.validate_dependencies()?;
 
@@ -867,6 +867,9 @@ impl WasmLoader {
                 let content = self.load_http_source(&url, &digest).await?;
                 Ok((content, export))
             }
+            v2::ComponentDependency::AppComponent { .. } => {
+                panic!("should have been normalised away by this point");
+            }
         }
     }
 }

crates/manifest/src/normalize.rs

@@ -1,16 +1,19 @@
 //! Manifest normalization functions.
 
-use std::collections::HashSet;
+use std::{collections::HashSet, path::PathBuf};
 
 use crate::schema::v2::{AppManifest, ComponentSpec, KebabId};
+use anyhow::Context;
 
 /// Normalizes some optional [`AppManifest`] features into a canonical form:
 /// - Inline components in trigger configs are moved into top-level
 ///   components and replaced with a reference.
 /// - Any triggers without an ID are assigned a generated ID.
-pub fn normalize_manifest(manifest: &mut AppManifest) {
+pub fn normalize_manifest(manifest: &mut AppManifest) -> anyhow::Result<()> {
     normalize_trigger_ids(manifest);
     normalize_inline_components(manifest);
+    normalize_dependency_component_refs(manifest)?;
+    Ok(())
 }
 
 fn normalize_inline_components(manifest: &mut AppManifest) {
@@ -103,3 +106,99 @@ fn normalize_trigger_ids(manifest: &mut AppManifest) {
         }
     }
 }
+
+use crate::schema::v2::{Component, ComponentDependency, ComponentSource};
+
+fn normalize_dependency_component_refs(manifest: &mut AppManifest) -> anyhow::Result<()> {
+    // `clone` a snapshot, because we are about to mutate collection elements,
+    // and the borrow checker gets mad at us if we try to index into the collection
+    // while that's happening.
+    let components = manifest.components.clone();
+
+    for (depender_id, component) in &mut manifest.components {
+        for dependency in component.dependencies.inner.values_mut() {
+            if let ComponentDependency::AppComponent {
+                component: depended_on_id,
+                export,
+            } = dependency
+            {
+                let depended_on = components
+                    .get(depended_on_id)
+                    .with_context(|| format!("dependency ID {depended_on_id} does not exist"))?;
+                ensure_is_acceptable_dependency(depended_on, depended_on_id, depender_id)?;
+                *dependency = component_source_to_dependency(&depended_on.source, export.clone());
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn component_source_to_dependency(
+    source: &ComponentSource,
+    export: Option<String>,
+) -> ComponentDependency {
+    match source {
+        ComponentSource::Local(path) => ComponentDependency::Local {
+            path: PathBuf::from(path),
+            export,
+        },
+        ComponentSource::Remote { url, digest } => ComponentDependency::HTTP {
+            url: url.clone(),
+            digest: digest.clone(),
+            export,
+        },
+        ComponentSource::Registry {
+            registry,
+            package,
+            version,
+        } => ComponentDependency::Package {
+            version: version.clone(),
+            registry: registry.as_ref().map(|r| r.to_string()),
+            package: Some(package.to_string()),
+            export,
+        },
+    }
+}
+
+/// If a dependency has things like files or KV stores or network access...
+/// those won't apply when it's composed, and that's likely to be surprising,
+/// and developers hate surprises.
+fn ensure_is_acceptable_dependency(
+    component: &Component,
+    depended_on_id: &KebabId,
+    depender_id: &KebabId,
+) -> anyhow::Result<()> {
+    let mut surprises = vec![];
+
+    if !component.ai_models.is_empty() {
+        surprises.push("ai_models");
+    }
+    if !component.allowed_outbound_hosts.is_empty() {
+        surprises.push("allowed_outbound_hosts");
+    }
+    if !component.dependencies.inner.is_empty() {
+        surprises.push("dependencies");
+    }
+    if !component.environment.is_empty() {
+        surprises.push("environment");
+    }
+    if !component.files.is_empty() {
+        surprises.push("files");
+    }
+    if !component.key_value_stores.is_empty() {
+        surprises.push("key_value_stores");
+    }
+    if !component.sqlite_databases.is_empty() {
+        surprises.push("sqlite_databases");
+    }
+    if !component.variables.is_empty() {
+        surprises.push("variables");
+    }
+
+    if surprises.is_empty() {
+        Ok(())
+    } else {
+        anyhow::bail!("Dependencies may not have their own resources or permissions. Component {depended_on_id} cannot be used as a dependency of {depender_id} because it specifies: {}", surprises.join(", "));
+    }
+}

crates/manifest/src/schema/v2.rs

@@ -187,6 +187,13 @@ impl TryFrom<toml::Value> for ComponentSpec {
 ///
 /// Example: `"my:dependency" = { path = "path/to/component.wasm", export = "my-export" }`
 ///
+/// - A component in the application. The referenced component binary is composed: additional
+///   configuration such as files, networking, storage, etc. are ignored. This is intended
+///   primarily as a convenience for including dependencies in the manifest so that they
+///   can be built using `spin build`.
+///
+/// Example: `"my:dependency" = { component_id = "my-dependency", export = "my-export" }`
+///
 /// - A package from an HTTP URL.
 ///
 /// Example: `"my:import" = { url = "https://example.com/component.wasm", sha256 = "sha256:..." }`
@@ -268,6 +275,22 @@ pub enum ComponentDependency {
         /// Learn more: https://spinframework.dev/writing-apps#dependencies-from-a-url
         export: Option<String>,
     },
+    /// `... = { component_id = "my-dependency" }`
+    #[schemars(description = "")] // schema docs are on the parent
+    AppComponent {
+        /// The ID of the component which implements the dependency.
+        ///
+        /// Example: `"my:dep/import" = { component = "my-dependency" }`
+        ///
+        /// Learn more: https://spinframework.dev/writing-apps#using-component-dependencies
+        component: KebabId,
+        /// The name of the export in the package. If omitted, this defaults to the name of the import.
+        ///
+        /// Example: `"my:dep/import" = { export = "your:impl/export", component = "my-dependency" }`
+        ///
+        /// Learn more: https://spinframework.dev/writing-apps#using-component-dependencies
+        export: Option<String>,
+    },
 }
 
 /// A Spin component.

crates/manifest/tests/ui.rs

@@ -45,6 +45,6 @@ fn run_v1_to_v2_test(input: &Path) -> Result<String, Failed> {
 
 fn run_normalization_test(input: impl AsRef<Path>) -> Result<String, Failed> {
     let mut manifest = spin_manifest::manifest_from_file(input)?;
-    normalize_manifest(&mut manifest);
+    normalize_manifest(&mut manifest)?;
     Ok(toml::to_string(&manifest).expect("serialization should work"))
 }