nixpacks 1.28.1

Generate an OCI compliant image based off app source
Documentation 
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use anyhow::Result;
use serde::{Deserialize, Serialize};

use crate::nixpacks::{
    app::App,
    environment::Environment,
    plan::{
        phase::{Phase, StartPhase},
        BuildPlan,
    },
};

use super::Provider;

#[derive(Serialize, Deserialize, Debug)]
struct GleamPackageSpec {
    pub name: String,
    pub version: String,
}

#[derive(Serialize, Deserialize, Debug)]
struct GleamManifest {
    pub packages: Vec<GleamPackageSpec>,
}

impl GleamManifest {
    fn get_package_version(&self, package: &str) -> Option<String> {
        Some(
            self.packages
                .iter()
                .find(|pkg| pkg.name == *package)?
                .version
                .clone(),
        )
    }
}

pub struct GleamProvider;

impl Provider for GleamProvider {
    fn name(&self) -> &str {
        "gleam"
    }

    fn detect(&self, app: &App, _env: &Environment) -> Result<bool> {
        Ok(app.has_match("gleam.toml") && app.has_match("manifest.toml"))
    }

    fn get_build_plan(&self, app: &App, env: &Environment) -> Result<Option<BuildPlan>> {
        let setup = self.get_setup(app, env);
        let install = self.get_install(app, env)?;
        let build = self.get_build(app, env);
        let start = self.get_start(app, env);

        let mut plan = BuildPlan::new(&[setup, install, build], Some(start));

        plan.add_static_assets(static_asset_list! {
            "get-gleam.sh" => include_str!("get-gleam.sh")
        });

        Ok(Some(plan))
    }
}

impl GleamProvider {
    fn get_setup(&self, _app: &App, _env: &Environment) -> Phase {
        // erlang and gleam are required, elixir just in case
        let pkgs = vec![
            "wget".into(),
            "erlang".into(),
            "elixir".into(),
            "rebar3".into(),
        ];

        Phase::setup(Some(pkgs))
    }

    fn get_install(&self, app: &App, _env: &Environment) -> Result<Phase> {
        let manifest: GleamManifest = app.read_toml("manifest.toml")?;

        let gleam_version = manifest.get_package_version("gleam_stdlib"); // steal the gleam version from the stdlib version

        let mut phase = Phase::install(Some(format!(
            "sh {} {}",
            app.asset_path("get-gleam.sh"),
            gleam_version.unwrap_or_else(|| "main".into())
        )));
        phase.only_include_files = Some(vec!["gleam.toml".into(), "manifest.toml".into()]);
        phase.add_cmd("gleam deps download");

        Ok(phase)
    }

    fn get_build(&self, _app: &App, _env: &Environment) -> Phase {
        Phase::build(Some("gleam export erlang-shipment".into()))
    }

    fn get_start(&self, _app: &App, _env: &Environment) -> StartPhase {
        let mut phase = StartPhase::new("./build/erlang-shipment/entrypoint.sh run");
        phase.only_include_files = Some(vec!["build/erlang-shipment".into()]);
        phase
    }
}