Initial commit

commands/lambda-new.md

@@ -0,0 +1,208 @@
+---
+description: Create a new Rust Lambda function project with cargo-lambda
+---
+
+You are helping the user create a new Rust Lambda function project using cargo-lambda.
+
+## Your Task
+
+Guide the user through creating a new Lambda function project with the following steps:
+
+1. **Check if cargo-lambda is installed**:
+   - Run `cargo lambda --version` to verify installation
+   - If not installed, provide installation instructions:
+     ```bash
+     # Via Homebrew (macOS/Linux)
+     brew tap cargo-lambda/cargo-lambda
+     brew install cargo-lambda
+
+     # Via pip
+     pip install cargo-lambda
+
+     # From source
+     cargo install cargo-lambda
+     ```
+
+2. **Ask for project details** (if not provided):
+   - Function name
+   - Event type (API Gateway, S3, SQS, EventBridge, custom, or basic)
+   - Workload type (IO-intensive, compute-intensive, or mixed)
+
+3. **Create the project**:
+   ```bash
+   cargo lambda new <function-name>
+   ```
+   Or with event type:
+   ```bash
+   cargo lambda new <function-name> --event-type <type>
+   ```
+
+4. **Set up the basic structure** based on workload type:
+
+   **For IO-intensive** (default):
+   - Use full async/await
+   - Add dependencies: tokio, reqwest, aws-sdk crates as needed
+   - Example handler with concurrent operations
+
+   **For compute-intensive**:
+   - Add rayon to Cargo.toml
+   - Example using spawn_blocking + rayon
+   - Async only at boundaries
+
+   **For mixed**:
+   - Both patterns combined
+   - Async for IO, sync for compute
+
+5. **Add essential dependencies** to Cargo.toml:
+   ```toml
+   [dependencies]
+   lambda_runtime = "0.13"
+   tokio = { version = "1", features = ["macros"] }
+   serde = { version = "1", features = ["derive"] }
+   serde_json = "1"
+   anyhow = "1"
+   thiserror = "1"
+   tracing = { version = "0.1", features = ["log"] }
+   tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+
+   # Add based on workload:
+   # For compute: rayon = "1.10"
+   # For HTTP: reqwest = { version = "0.12", features = ["json"] }
+   # For AWS services: aws-sdk-* crates
+   ```
+
+6. **Configure release profile** for optimization:
+   ```toml
+   [profile.release]
+   opt-level = 'z'     # Optimize for size
+   lto = true          # Link-time optimization
+   codegen-units = 1   # Better optimization
+   strip = true        # Remove debug symbols
+   panic = 'abort'     # Smaller panic handler
+   ```
+
+7. **Create example handler** matching the selected pattern
+
+8. **Test locally**:
+   ```bash
+   cd <function-name>
+   cargo lambda watch
+
+   # In another terminal:
+   cargo lambda invoke --data-ascii '{"key": "value"}'
+   ```
+
+## Event Type Templates
+
+Provide appropriate code based on event type:
+
+- **basic**: Simple JSON request/response
+- **apigw**: API Gateway proxy request/response
+- **s3**: S3 event processing
+- **sqs**: SQS message processing
+- **eventbridge**: EventBridge/CloudWatch Events
+
+## Example Handlers
+
+Show the user a complete working example for their chosen pattern:
+
+### IO-Intensive Example
+```rust
+use lambda_runtime::{run, service_fn, Error, LambdaEvent};
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+struct Request {
+    user_ids: Vec<String>,
+}
+
+#[derive(Serialize)]
+struct Response {
+    count: usize,
+}
+
+async fn function_handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
+    // Concurrent async operations
+    let futures = event.payload.user_ids
+        .into_iter()
+        .map(|id| fetch_user_data(&id));
+
+    let results = futures::future::try_join_all(futures).await?;
+
+    Ok(Response { count: results.len() })
+}
+
+async fn fetch_user_data(id: &str) -> Result<(), Error> {
+    // Async IO operation
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::INFO)
+        .without_time()
+        .init();
+
+    run(service_fn(function_handler)).await
+}
+```
+
+### Compute-Intensive Example
+```rust
+use lambda_runtime::{run, service_fn, Error, LambdaEvent};
+use rayon::prelude::*;
+use serde::{Deserialize, Serialize};
+use tokio::task;
+
+#[derive(Deserialize)]
+struct Request {
+    numbers: Vec<i64>,
+}
+
+#[derive(Serialize)]
+struct Response {
+    results: Vec<i64>,
+}
+
+async fn function_handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
+    let numbers = event.payload.numbers;
+
+    // CPU work in spawn_blocking with Rayon
+    let results = task::spawn_blocking(move || {
+        numbers
+            .par_iter()
+            .map(|&n| expensive_computation(n))
+            .collect::<Vec<_>>()
+    })
+    .await?;
+
+    Ok(Response { results })
+}
+
+fn expensive_computation(n: i64) -> i64 {
+    // CPU-intensive work
+    (0..1000).fold(n, |acc, _| acc.wrapping_mul(31))
+}
+
+#[tokio::main]
+async fn main() -> Result<(), Error> {
+    tracing_subscriber::fmt()
+        .with_max_level(tracing::Level::INFO)
+        .without_time()
+        .init();
+
+    run(service_fn(function_handler)).await
+}
+```
+
+## Next Steps
+
+After creating the project, suggest:
+1. Review and customize the handler
+2. Add tests
+3. Test locally with `cargo lambda watch`
+4. Build with `/lambda-build`
+5. Deploy with `/lambda-deploy`
+
+Be helpful and guide the user through any questions or issues they encounter.