cargo-lambda · calavera · Mar 6, 2025 · Mar 5, 2025 · Mar 5, 2025
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -30,7 +30,7 @@ exclude = [
 resolver = "2"
 
 [workspace.package]
-version = "1.7.0"
+version = "1.7.1"
 authors = ["David Calavera"]
 edition = "2024"
 license = "MIT"
@@ -52,15 +52,15 @@ aws-smithy-runtime = { version = "1.7.5", features = ["test-util"] }
 aws-smithy-types = "1.2.10"
 aws-types = "1.3.3"
 base64 = "0.21.2"
-cargo-lambda-build = { version = "1.7.0", path = "crates/cargo-lambda-build" }
-cargo-lambda-deploy = { version = "1.7.0", path = "crates/cargo-lambda-deploy" }
-cargo-lambda-interactive = { version = "1.7.0", path = "crates/cargo-lambda-interactive" }
-cargo-lambda-invoke = { version = "1.7.0", path = "crates/cargo-lambda-invoke" }
-cargo-lambda-metadata = { version = "1.7.0", path = "crates/cargo-lambda-metadata" }
-cargo-lambda-new = { version = "1.7.0", path = "crates/cargo-lambda-new" }
-cargo-lambda-remote = { version = "1.7.0", path = "crates/cargo-lambda-remote" }
-cargo-lambda-system = { version = "1.7.0", path = "crates/cargo-lambda-system" }
-cargo-lambda-watch = { version = "1.7.0", path = "crates/cargo-lambda-watch" }
+cargo-lambda-build = { version = "1.7.1", path = "crates/cargo-lambda-build" }
+cargo-lambda-deploy = { version = "1.7.1", path = "crates/cargo-lambda-deploy" }
+cargo-lambda-interactive = { version = "1.7.1", path = "crates/cargo-lambda-interactive" }
+cargo-lambda-invoke = { version = "1.7.1", path = "crates/cargo-lambda-invoke" }
+cargo-lambda-metadata = { version = "1.7.1", path = "crates/cargo-lambda-metadata" }
+cargo-lambda-new = { version = "1.7.1", path = "crates/cargo-lambda-new" }
+cargo-lambda-remote = { version = "1.7.1", path = "crates/cargo-lambda-remote" }
+cargo-lambda-system = { version = "1.7.1", path = "crates/cargo-lambda-system" }
+cargo-lambda-watch = { version = "1.7.1", path = "crates/cargo-lambda-watch" }
 cargo_metadata = "0.15.3"
 cargo-options = { version = "0.7.5", features = ["serde"] }
 cargo-zigbuild = "0.19.4"

diff --git a/crates/cargo-lambda-cli/tests/cargo_lambda.rs b/crates/cargo-lambda-cli/tests/cargo_lambda.rs
@@ -707,3 +707,27 @@ fn test_deploy_pre_existing_zip_file() {
         );
     }
 }
+
+#[test]
+fn test_deploy_with_memory_and_timeout_cli_flags() {
+    let _guard = init_root();
+    let lp = cargo_lambda_new("test-http-function", "function-template");
+
+    lp.new_cmd().arg("--http").arg(&lp.name).assert().success();
+    let project = lp.test_project();
+
+    cargo_lambda_build(project.root()).assert().success();
+
+    #[cfg(not(windows))]
+    {
+        let output = cargo_lambda_dry_deploy(project.root())
+            .args(["--memory", "512"])
+            .args(["--timeout", "60"])
+            .assert()
+            .success();
+
+        let json_data = deploy_output_json(&output).unwrap();
+        assert_eq!(json_data["config"]["memory"].as_i64().unwrap(), 512);
+        assert_eq!(json_data["config"]["timeout"].as_i64().unwrap(), 60);
+    }
+}
diff --git a/crates/cargo-lambda-metadata/src/cargo/deploy.rs b/crates/cargo-lambda-metadata/src/cargo/deploy.rs
@@ -11,7 +11,7 @@ use crate::{
     cargo::deserialize_vec_or_map,
     env::EnvOptions,
     error::MetadataError,
-    lambda::{Memory, Timeout, Tracing},
+    lambda::{Memory, MemoryValueParser, Timeout, Tracing},
 };
 
 const DEFAULT_MANIFEST_PATH: &str = "Cargo.toml";
@@ -285,8 +285,8 @@ pub struct FunctionDeployConfig {
     #[serde(default)]
     pub disable_function_url: bool,
 
-    /// Memory allocated for the function
-    #[arg(long, alias = "memory-size", value_parser = clap::value_parser!(i32).range(128..=10240))]
+    /// Memory allocated for the function. Value must be between 128 and 10240.
+    #[arg(long, alias = "memory-size", value_parser = MemoryValueParser)]
     #[serde(default)]
     pub memory: Option<Memory>,
 
@@ -616,7 +616,7 @@ mod tests {
             config.deploy.function_config.timeout,
             Some(Timeout::new(120))
         );
-        assert_eq!(config.deploy.function_config.memory, Some(Memory(10240)));
+        assert_eq!(config.deploy.function_config.memory, Some(10240.into()));
 
         let tags = config.deploy.lambda_tags().unwrap();
         assert_eq!(tags.len(), 2);

diff --git a/crates/cargo-lambda-metadata/src/config.rs b/crates/cargo-lambda-metadata/src/config.rs
@@ -254,7 +254,7 @@ mod tests {
         );
 
         assert_eq!(config.env.get("FOO"), Some(&"BAR".to_string()));
-        assert_eq!(config.deploy.function_config.memory, Some(Memory(512)));
+        assert_eq!(config.deploy.function_config.memory, Some(512.into()));
         assert_eq!(config.deploy.function_config.timeout, Some(60.into()));
 
         assert_eq!(
@@ -374,7 +374,7 @@ mod tests {
 
         let metadata = load_metadata(manifest).unwrap();
         let config = load_config_without_cli_flags(&metadata, &options).unwrap();
-        assert_eq!(config.deploy.function_config.memory, Some(Memory(1024)));
+        assert_eq!(config.deploy.function_config.memory, Some(1024.into()));
 
         let options = ConfigOptions {
             context: Some("development".to_string()),
@@ -383,15 +383,15 @@ mod tests {
         };
 
         let config = load_config_without_cli_flags(&metadata, &options).unwrap();
-        assert_eq!(config.deploy.function_config.memory, Some(Memory(512)));
+        assert_eq!(config.deploy.function_config.memory, Some(512.into()));
 
         let options = ConfigOptions {
             global: Some(global),
             ..Default::default()
         };
 
         let config = load_config_without_cli_flags(&metadata, &options).unwrap();
-        assert_eq!(config.deploy.function_config.memory, Some(Memory(256)));
+        assert_eq!(config.deploy.function_config.memory, Some(256.into()));
     }
 
     #[test]
@@ -406,7 +406,7 @@ mod tests {
         };
 
         let mut deploy = Deploy::default();
-        deploy.function_config.memory = Some(Memory(2048));
+        deploy.function_config.memory = Some(2048.into());
 
         let args_config = Config {
             deploy,
@@ -415,6 +415,6 @@ mod tests {
 
         let metadata = load_metadata(manifest).unwrap();
         let config = load_config(&args_config, &metadata, &options).unwrap();
-        assert_eq!(config.deploy.function_config.memory, Some(Memory(2048)));
+        assert_eq!(config.deploy.function_config.memory, Some(2048.into()));
     }
 }
diff --git a/crates/cargo-lambda-metadata/src/error.rs b/crates/cargo-lambda-metadata/src/error.rs
@@ -8,7 +8,7 @@ use thiserror::Error;
 pub enum MetadataError {
     #[error("invalid memory value `{0}`")]
     #[diagnostic()]
-    InvalidMemory(i32),
+    InvalidMemory(String),
     #[error("invalid lambda metadata in Cargo.toml file: {0}")]
     #[diagnostic()]
     InvalidCargoMetadata(#[from] serde_json::Error),

diff --git a/crates/cargo-lambda-metadata/src/lambda.rs b/crates/cargo-lambda-metadata/src/lambda.rs
@@ -1,8 +1,13 @@
+use clap::{
+    Arg, Command,
+    builder::TypedValueParser,
+    error::{ContextKind, ContextValue},
+};
 use serde::{
     Deserialize, Serialize, Serializer,
     de::{Deserializer, Error, Visitor},
 };
-use std::{fmt, str::FromStr, time::Duration};
+use std::{ffi::OsStr, fmt, str::FromStr, time::Duration};
 use strum_macros::{Display, EnumString};
 
 use crate::error::MetadataError;
@@ -59,7 +64,7 @@ impl From<i32> for Timeout {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Memory(pub i32);
+pub struct Memory(u32);
 
 impl From<Memory> for i32 {
     fn from(m: Memory) -> i32 {
@@ -69,18 +74,34 @@ impl From<Memory> for i32 {
 
 impl From<&Memory> for i32 {
     fn from(m: &Memory) -> i32 {
-        m.0
+        m.0 as i32
+    }
+}
+
+impl From<i32> for Memory {
+    fn from(t: i32) -> Memory {
+        Memory(t as u32)
     }
 }
 
-impl TryFrom<i32> for Memory {
+impl TryFrom<i64> for Memory {
     type Error = MetadataError;
 
-    fn try_from(m: i32) -> Result<Memory, Self::Error> {
+    fn try_from(m: i64) -> Result<Memory, Self::Error> {
         if !(128..=10240).contains(&m) {
-            return Err(MetadataError::InvalidMemory(m));
+            return Err(MetadataError::InvalidMemory(format!("{m}")));
         }
-        Ok(Memory(m))
+        Ok(Memory(m as u32))
+    }
+}
+
+impl FromStr for Memory {
+    type Err = MetadataError;
+
+    fn from_str(t: &str) -> Result<Memory, Self::Err> {
+        let t = i64::from_str(t).map_err(|_| MetadataError::InvalidMemory(t.into()))?;
+
+        t.try_into()
     }
 }
 
@@ -101,7 +122,7 @@ impl<'de> Deserialize<'de> for Memory {
             where
                 E: Error,
             {
-                Memory::try_from(value as i32).map_err(|e| Error::custom(e.to_string()))
+                Memory::try_from(value).map_err(|e| Error::custom(e.to_string()))
             }
 
             fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
@@ -125,6 +146,39 @@ impl Serialize for Memory {
     }
 }
 
+#[derive(Clone)]
+pub struct MemoryValueParser;
+impl TypedValueParser for MemoryValueParser {
+    type Value = Memory;
+
+    fn parse_ref(
+        &self,
+        cmd: &Command,
+        arg: Option<&Arg>,
+        value: &OsStr,
+    ) -> Result<Self::Value, clap::Error> {
+        let val = value
+            .to_str()
+            .ok_or_else(|| clap::Error::new(clap::error::ErrorKind::InvalidUtf8).with_cmd(cmd))?;
+
+        Memory::from_str(val).map_err(|_| {
+            let mut err = clap::Error::new(clap::error::ErrorKind::ValueValidation).with_cmd(cmd);
+
+            if let Some(arg) = arg {
+                err.insert(
+                    ContextKind::InvalidArg,
+                    ContextValue::String(arg.to_string()),
+                );
+            }
+
+            let context = ContextValue::String(val.to_string());
+            err.insert(ContextKind::InvalidValue, context);
+
+            err
+        })
+    }
+}
+
 #[derive(Clone, Debug, Default, Display, EnumString, Eq, PartialEq, Serialize)]
 #[strum(ascii_case_insensitive)]
 pub enum Tracing {

diff --git a/crates/cargo-lambda-metadata/tests/jail.rs b/crates/cargo-lambda-metadata/tests/jail.rs
@@ -33,7 +33,7 @@ fn test_env() {
         let config = load_config_without_cli_flags(&metadata, &ConfigOptions::default()).unwrap();
 
         assert!(config.build.cargo_opts.release);
-        assert_eq!(config.deploy.function_config.memory, Some(Memory(1024)));
+        assert_eq!(config.deploy.function_config.memory, Some(1024.into()));
         assert_eq!(config.deploy.function_config.timeout, Some(60.into()));
 
         Ok(())
@@ -65,7 +65,7 @@ fn test_env_with_context() {
         let metadata = load_metadata("Cargo.toml").unwrap();
         let config = load_config_without_cli_flags(&metadata, &options).unwrap();
 
-        assert_eq!(config.deploy.function_config.memory, Some(Memory(1024)));
+        assert_eq!(config.deploy.function_config.memory, Some(1024.into()));
 
         Ok(())
     });