Rust crate or example for AWS lambda or Netlify Functions

use std::{env, str::FromStr};

use aws_lambda_events::encodings::Body;
use aws_lambda_events::event::apigw::ApiGatewayProxyResponse;
use http::header::HeaderMap;
use lambda_runtime::{
    service_fn,
    tracing::{self},
    Error, LambdaEvent,
};
use rustls::ClientConfig;
use rustls_platform_verifier::ConfigVerifierExt;
use serde_json::Value;
use tokio_postgres::Config;

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing::init_default_subscriber();

    let handler = service_fn(handler);
    lambda_runtime::run(handler).await?;
    Ok(())
}

use std::{env, str::FromStr};

use aws_lambda_events::encodings::Body;
use aws_lambda_events::event::apigw::ApiGatewayProxyResponse;
use http::header::HeaderMap;
use lambda_runtime::{
    service_fn,
    tracing::{self},
    Error, LambdaEvent,
};
use rustls::ClientConfig;
use rustls_platform_verifier::ConfigVerifierExt;
use serde_json::Value;
use tokio_postgres::Config;

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing::init_default_subscriber();

    let handler = service_fn(handler);
    lambda_runtime::run(handler).await?;
    Ok(())
}

async fn handler(_event: LambdaEvent<Value>) -> Result<ApiGatewayProxyResponse, Error> {
    // Pull the db url from the environment
    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    // Used to store the results of the query
    let mut result_json = "".to_string();

    // Create a new connection to the database
    // Setup the TLS configuration for the connection using native certs
    // Using https://crates.io/crates/rustls-platform-verifier
    // replaces using rustls-native-certs on its own (recommended)
    let config = ClientConfig::with_platform_verifier();
    let tls = tokio_postgres_rustls::MakeRustlsConnect::new(config);

    // Setup the Config struct using the connection string
    let config = Config::from_str(db_url.as_str()).unwrap();
    // get the client and connection future
    let (client, conn) = config
        .connect(tls)
        .await
        .map_err(|err| format!("Error connecting to PostgreSQL: {}", err))?;

    // The connection future performs the actual communication with the database,
    // so spawn it off to run on its own.
    tokio::spawn(async move {
        if let Err(e) = conn.await {
            eprintln!("connection error: {}", e);
        }
    });

async fn handler(_event: LambdaEvent<Value>) -> Result<ApiGatewayProxyResponse, Error> {
    // Pull the db url from the environment
    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");

    // Used to store the results of the query
    let mut result_json = "".to_string();

    // Create a new connection to the database
    // Setup the TLS configuration for the connection using native certs
    // Using https://crates.io/crates/rustls-platform-verifier
    // replaces using rustls-native-certs on its own (recommended)
    let config = ClientConfig::with_platform_verifier();
    let tls = tokio_postgres_rustls::MakeRustlsConnect::new(config);

    // Setup the Config struct using the connection string
    let config = Config::from_str(db_url.as_str()).unwrap();
    // get the client and connection future
    let (client, conn) = config
        .connect(tls)
        .await
        .map_err(|err| format!("Error connecting to PostgreSQL: {}", err))?;

    // The connection future performs the actual communication with the database,
    // so spawn it off to run on its own.
    tokio::spawn(async move {
        if let Err(e) = conn.await {
            eprintln!("connection error: {}", e);
        }
    });

    // Perform a query to get the posts (Vec<Row>) from the database
    for row in client.query("select * from posts", &[]).await? {
        let ret: i32 = row.get(0);
        let title: &str = row.get(1);
        let contents: &str = row.get(2);
        let published: bool = row.get(3);

        if result_json.len() > 0 {
            result_json.push_str(",");
        }
        result_json.push_str(&format!(
            "{{\"id\": {}, \"title\": \"{}\", \"contents\": \"{}\", \"published\": {}}}",
            ret, title, contents, published
        ));
    }
    let result_json = format!("[{}]", result_json);

    // Headers for the lambda response
    let mut headers = HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let resp = ApiGatewayProxyResponse {
        status_code: 200,
        headers: headers.clone(),
        multi_value_headers: HeaderMap::new(),
        body: Some(Body::Text(result_json.into())),
        is_base64_encoded: false,
    };

    Ok(resp)
}

    // Perform a query to get the posts (Vec<Row>) from the database
    for row in client.query("select * from posts", &[]).await? {
        let ret: i32 = row.get(0);
        let title: &str = row.get(1);
        let contents: &str = row.get(2);
        let published: bool = row.get(3);

        if result_json.len() > 0 {
            result_json.push_str(",");
        }
        result_json.push_str(&format!(
            "{{\"id\": {}, \"title\": \"{}\", \"contents\": \"{}\", \"published\": {}}}",
            ret, title, contents, published
        ));
    }
    let result_json = format!("[{}]", result_json);

    // Headers for the lambda response
    let mut headers = HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let resp = ApiGatewayProxyResponse {
        status_code: 200,
        headers: headers.clone(),
        multi_value_headers: HeaderMap::new(),
        body: Some(Body::Text(result_json.into())),
        is_base64_encoded: false,
    };

    Ok(resp)
}