l3_cli 0.0.4

Lambda compute tooling
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

use l3_fn_build::runtime::node::NodeConfig;
use l3_fn_build::runtime::Runtime;
use l3_fn_build::{FnEntrypoint, FnParseSpec};
use std::path::PathBuf;
use std::sync::Arc;
use tokio::task::JoinSet;

// todo rewrite panics to proper error handling
pub async fn collect_handlers(project_dir: &Arc<PathBuf>) -> Vec<FnEntrypoint> {
    let routes_dir = project_dir.join("routes");
    if !routes_dir.is_dir() {
        return vec![];
    }
    let mut join_set: JoinSet<Option<FnEntrypoint>> = JoinSet::new();
    for path in l3_api_base::collect_files(&project_dir.join("routes")) {
        if let Some(file_name) = path.file_name() {
            if matches!(
                file_name.to_string_lossy().as_ref(),
                "lambda.js" | "lambda.mjs" | "lambda.py" | "lambda.ts"
            ) {
                join_set.spawn(parse_entrypoint(
                    path.strip_prefix(project_dir.as_ref())
                        .unwrap()
                        .to_path_buf(),
                    project_dir.clone(),
                ));
            }
        }
    }
    let mut result = Vec::new();
    while let Some(join_result) = join_set.join_next().await {
        if let Some(handlers_found) = join_result.unwrap() {
            result.push(handlers_found);
        }
    }
    result
}

async fn parse_entrypoint(entrypoint: PathBuf, project_dir: Arc<PathBuf>) -> Option<FnEntrypoint> {
    let runtime = match entrypoint.extension().unwrap().to_string_lossy().as_ref() {
        "js" | "mjs" | "ts" => Runtime::Node(Arc::new(
            NodeConfig::read_node_config(project_dir.as_path()).unwrap(),
        )),
        "py" => Runtime::Python,
        _ => panic!(),
    };
    let entrypoint = l3_fn_build::parse_entrypoint(FnParseSpec {
        entrypoint: entrypoint.clone(),
        project_dir,
        runtime,
    })
    .await
    .unwrap();
    if entrypoint.handlers.is_empty() {
        None
    } else {
        Some(entrypoint)
    }
}