Fix rebasing issues

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

Author: rylev

Cargo.lock

@@ -70,7 +70,7 @@ terminal = { path = "crates/terminal" }
 subprocess = "0.2.9"
 tempfile = "3.8.0"
 tokio = { version = "1.23", features = ["full"] }
-toml = "0.6"
+toml = "0.8"
 tracing = { workspace = true }
 url = "2.2.2"
 uuid = { version = "^1.0", features = ["v4"] }

Cargo.toml

@@ -211,6 +211,7 @@ fn expand_factors(input: &DeriveInput) -> syn::Result<TokenStream> {
             )*
         }
 
+        #[allow(dead_code)]
         impl #builders_name {
             #(
                 pub fn #factor_names(&mut self) -> &mut <#factor_types as #Factor>::InstanceBuilder {

crates/factors-derive/src/lib.rs

@@ -7,7 +7,7 @@ use spin_factors::{AsInstanceState, ConfiguredApp, RuntimeFactors, RuntimeFactor
 
 /// A FactorsExecutor manages execution of a Spin app.
 ///
-/// `Factors` is the executor's [`RuntimeFactors`]. `ExecutorInstanceState`
+/// It is generic over the executor's [`RuntimeFactors`]. Additionally, it
 /// holds any other per-instance state needed by the caller.
 pub struct FactorsExecutor<T: RuntimeFactors, U = ()> {
     core_engine: spin_core::Engine<InstanceState<T::InstanceState, U>>,
@@ -110,6 +110,9 @@ type InstancePre<T, U> =
     spin_core::InstancePre<InstanceState<<T as RuntimeFactors>::InstanceState, U>>;
 
 /// A FactorsExecutorApp represents a loaded Spin app, ready for instantiation.
+///
+/// It is generic over the executor's [`RuntimeFactors`] and any ad-hoc additional
+/// per-instance state needed by the caller.
 pub struct FactorsExecutorApp<T: RuntimeFactors, U> {
     executor: FactorsExecutor<T, U>,
     configured_app: ConfiguredApp<T>,
@@ -173,14 +176,16 @@ impl<T: RuntimeFactors, U: Send + 'static> FactorsExecutorApp<T, U> {
     }
 }
 
-/// A FactorsInstanceBuilder manages the instantiation of a Spin component
-/// instance.
-pub struct FactorsInstanceBuilder<'a, T: RuntimeFactors, U> {
+/// A FactorsInstanceBuilder manages the instantiation of a Spin component instance.
+///
+/// It is generic over the executor's [`RuntimeFactors`] and any ad-hoc additional
+/// per-instance state needed by the caller.
+pub struct FactorsInstanceBuilder<'a, F: RuntimeFactors, U> {
     app_component: AppComponent<'a>,
     store_builder: spin_core::StoreBuilder,
-    factor_builders: T::InstanceBuilders,
-    instance_pre: &'a InstancePre<T, U>,
-    factors: &'a T,
+    factor_builders: F::InstanceBuilders,
+    instance_pre: &'a InstancePre<F, U>,
+    factors: &'a F,
 }
 
 impl<'a, T: RuntimeFactors, U> FactorsInstanceBuilder<'a, T, U> {
@@ -221,6 +226,9 @@ impl<'a, T: RuntimeFactors, U: Send> FactorsInstanceBuilder<'a, T, U> {
 }
 
 /// InstanceState is the [`spin_core::Store`] `data` for an instance.
+///
+/// It is generic over the [`RuntimeFactors::InstanceState`] and any ad-hoc
+/// data needed by the caller.
 pub struct InstanceState<T, U> {
     core: spin_core::State,
     factors: T,

crates/factors-executor/src/lib.rs

@@ -81,7 +81,9 @@ pub trait RuntimeFactors: Send + Sync + Sized + 'static {
     ) -> Option<Option<&mut F::InstanceBuilder>>;
 }
 
+/// Allows querying an `InstanceBuilders` for a particular `Factor`'s `InstanceBuilder`.
 pub trait HasInstanceBuilder {
+    /// Get the instance builder of a particular factor.
     fn for_factor<F: Factor>(&mut self) -> Option<&mut F::InstanceBuilder>;
 }
 

crates/factors/src/runtime_factors.rs

@@ -118,7 +118,7 @@ where
             sqlite_resolver: sqlite_config_resolver,
             state_dir: toml_resolver.state_dir()?,
             log_dir: toml_resolver.log_dir()?,
-            toml,
+            toml: toml_resolver.toml(),
         })
     }
 
@@ -262,6 +262,10 @@ impl<'a> TomlResolver<'a> {
     pub fn validate_all_keys_used(&self) -> spin_factors::Result<()> {
         self.table.validate_all_keys_used()
     }
+
+    fn toml(&self) -> toml::Table {
+        self.table.as_ref().clone()
+    }
 }
 
 /// The TOML based runtime configuration source Spin CLI.

crates/runtime-config/src/lib.rs

@@ -30,7 +30,10 @@ pub use tls::TlsConfig;
 
 pub(crate) use wasmtime_wasi_http::body::HyperIncomingBody as Body;
 
+/// A [`spin_trigger::TriggerApp`] for the HTTP trigger.
 pub(crate) type TriggerApp<F> = spin_trigger::TriggerApp<HttpTrigger, F>;
+
+/// A [`spin_trigger::TriggerInstanceBuilder`] for the HTTP trigger.
 pub(crate) type TriggerInstanceBuilder<'a, F> =
     spin_trigger::TriggerInstanceBuilder<'a, HttpTrigger, F>;
 

crates/trigger-http/src/lib.rs

@@ -79,7 +79,7 @@ impl HttpExecutor for WagiHttpExecutor {
             .factor_builders()
             .for_factor::<WasiFactor>()
         {
-            // // Set up Wagi environment
+            // Set up Wagi environment
             wasi_builder.args(argv.split(' '));
             wasi_builder.env(headers);
             wasi_builder.stdin_pipe(Cursor::new(body));

crates/trigger-http/src/wagi.rs

@@ -26,7 +26,6 @@ spin-factor-sqlite = { path = "../factor-sqlite" }
 spin-factor-wasi = { path = "../factor-wasi" }
 spin-factors = { path = "../factors" }
 spin-factors-executor = { path = "../factors-executor" }
-spin-runtime-config = { path = "../runtime-config" }
 spin-telemetry = { path = "../telemetry" }
 tokio = { version = "1.23", features = ["fs", "rt"] }
 toml = "0.8"

crates/trigger/Cargo.toml

@@ -23,7 +23,7 @@ pub use launch_metadata::LaunchMetadata;
 pub use sqlite_statements::SqlStatementExecutorHook;
 use stdio::FollowComponents;
 pub use stdio::StdioLoggingExecutorHooks;
-pub use summary::KeyValueDefaultStoreSummaryHook;
+pub use summary::{KeyValueDefaultStoreSummaryHook, SqliteDefaultStoreSummaryHook};
 
 pub const APP_LOG_DIR: &str = "APP_LOG_DIR";
 pub const DISABLE_WASMTIME_CACHE: &str = "DISABLE_WASMTIME_CACHE";
@@ -398,8 +398,11 @@ impl<T: Trigger<B::Factors>, B: RuntimeFactorsBuilder> TriggerAppBuilder<T, B> {
 
 /// A builder for runtime factors.
 pub trait RuntimeFactorsBuilder {
-    type Options: clap::Args;
+    /// The factors type to build.
     type Factors: RuntimeFactors;
+    /// CLI arguments not included in [`CommonTriggerOptions`] needed  to build the [`RuntimeFactors`].
+    type Options: clap::Args;
+    /// The wrapped runtime config type.
     type RuntimeConfig: Into<<Self::Factors as RuntimeFactors>::RuntimeConfig>;
 
     /// Build the factors and runtime config from the given options.