refactor: passes env down to deployment modules

cli/cmd/cmds/module/template.go

@@ -55,7 +55,7 @@ func (c *TemplateCmd) Run(ctx run.RunContext) error {
 	manifests := make(map[string][]byte)
 	gen := generator.NewGenerator(ctx.ManifestGeneratorStore, ctx.Logger)
 	if c.Module != "" {
-		mod, ok := bundle.Bundle[c.Module]
+		mod, ok := bundle.Bundle.Modules[c.Module]
 		if !ok {
 			return fmt.Errorf("module %q not found", c.Module)
 		}
@@ -65,7 +65,7 @@ func (c *TemplateCmd) Run(ctx run.RunContext) error {
 			mod.Path = path
 		}
 
-		out, err := gen.Generate(mod)
+		out, err := gen.Generate(mod, bundle.Bundle.Env)
 		if err != nil {
 			return fmt.Errorf("failed to generate manifest: %w", err)
 		}
@@ -75,13 +75,13 @@ func (c *TemplateCmd) Run(ctx run.RunContext) error {
 	} else {
 		if c.SetPath != nil {
 			for name, path := range c.SetPath {
-				mod, ok := bundle.Bundle[name]
+				mod, ok := bundle.Bundle.Modules[name]
 				if !ok {
 					return fmt.Errorf("module %q not found", name)
 				}
 
 				mod.Path = path
-				bundle.Bundle[name] = mod
+				bundle.Bundle.Modules[name] = mod
 			}
 		}
 

foundry/api/blueprint.cue

@@ -18,10 +18,11 @@ project: {
 			merge: {}
 			tag: {}
 		}
-		modules: {
-			main: {
+		bundle: {
+			env: "shared-services"
+			modules: main: {
 				name:    "app"
-				version: "0.4.0"
+				version: "0.4.3"
 				values: {
 					deployment: containers: main: {
 						image: {

lib/project/blueprint/defaults/deployment.go

@@ -13,7 +13,7 @@ func (d DeploymentModuleSetter) SetDefault(v cue.Value) (cue.Value, error) {
 	projectName, _ := v.LookupPath(cue.ParsePath("project.name")).String()
 	registry, _ := v.LookupPath(cue.ParsePath("global.deployment.registries.modules")).String()
 
-	modules := v.LookupPath(cue.ParsePath("project.deployment.modules"))
+	modules := v.LookupPath(cue.ParsePath("project.deployment.bundle.modules"))
 	if !modules.Exists() || modules.Err() != nil {
 		return v, nil
 	}
@@ -30,14 +30,14 @@ func (d DeploymentModuleSetter) SetDefault(v cue.Value) (cue.Value, error) {
 		if projectName != "" {
 			instance := module.LookupPath(cue.ParsePath("instance"))
 			if !instance.Exists() {
-				v = v.FillPath(cue.ParsePath(fmt.Sprintf("project.deployment.modules.%s.instance", moduleName)), projectName)
+				v = v.FillPath(cue.ParsePath(fmt.Sprintf("project.deployment.bundle.modules.%s.instance", moduleName)), projectName)
 			}
 		}
 
 		if registry != "" {
 			r := module.LookupPath(cue.ParsePath("registry"))
 			if !r.Exists() {
-				v = v.FillPath(cue.ParsePath(fmt.Sprintf("project.deployment.modules.%s.registry", moduleName)), registry)
+				v = v.FillPath(cue.ParsePath(fmt.Sprintf("project.deployment.bundle.modules.%s.registry", moduleName)), registry)
 			}
 		}
 	}

lib/project/deployment/deployer/deployer.go

@@ -52,6 +52,10 @@ type Deployer struct {
 
 // DeployProject deploys the manifests for a project to the GitOps repository.
 func (d *Deployer) Deploy() error {
+	if d.project.Blueprint.Project.Deployment.Bundle.Env == "prod" {
+		return fmt.Errorf("cannot deploy to production environment")
+	}
+
 	r, err := d.clone()
 	if err != nil {
 		return err
@@ -134,7 +138,8 @@ func (d *Deployer) Deploy() error {
 // buildProjectPath builds the path to the project in the GitOps repository.
 func (d *Deployer) buildProjectPath() string {
 	globalDeploy := d.project.Blueprint.Global.Deployment
-	return fmt.Sprintf(PATH, globalDeploy.Root, DEFAULT_ENV, d.project.Name)
+	env := d.project.Blueprint.Project.Deployment.Bundle.Env
+	return fmt.Sprintf(PATH, globalDeploy.Root, env, d.project.Name)
 }
 
 // checkProjectPath checks if the project path exists and creates it if it does not.

lib/project/deployment/deployer/deployer_test.go

@@ -38,7 +38,7 @@ func TestDeployerDeploy(t *testing.T) {
 			Blueprint: sb.Blueprint{
 				Project: &sp.Project{
 					Deployment: &sp.Deployment{
-						Modules: bundle,
+						Bundle: bundle,
 					},
 				},
 				Global: &sg.Global{
@@ -85,51 +85,56 @@ func TestDeployerDeploy(t *testing.T) {
 			project: newProject(
 				"project",
 				sp.ModuleBundle{
-					"main": {
-						Instance:  "instance",
-						Name:      "module",
-						Namespace: "default",
-						Registry:  "registry",
-						Type:      "kcl",
-						Values:    map[string]string{"key": "value"},
-						Version:   "v1.0.0",
+					Env: "test",
+					Modules: map[string]sp.Module{
+						"main": {
+							Instance:  "instance",
+							Name:      "module",
+							Namespace: "default",
+							Registry:  "registry",
+							Type:      "kcl",
+							Values:    map[string]string{"key": "value"},
+							Version:   "v1.0.0",
+						},
 					},
 				},
 			),
 			files: map[string]string{
-				mkPath("dev", "project", "env.mod.cue"): `main: values: { key1: "value1" }`,
+				mkPath("test", "project", "env.mod.cue"): `main: values: { key1: "value1" }`,
 			},
 			dryrun: false,
 			validate: func(t *testing.T, r testResult) {
 				require.NoError(t, r.err)
 
-				e, err := afero.Exists(r.fs, mkPath("dev", "project", "main.yaml"))
+				e, err := afero.Exists(r.fs, mkPath("test", "project", "main.yaml"))
 				require.NoError(t, err)
 				assert.True(t, e)
 
-				e, err = afero.Exists(r.fs, mkPath("dev", "project", "mod.cue"))
+				e, err = afero.Exists(r.fs, mkPath("test", "project", "mod.cue"))
 				require.NoError(t, err)
 				assert.True(t, e)
 
-				c, err := afero.ReadFile(r.fs, mkPath("dev", "project", "main.yaml"))
+				c, err := afero.ReadFile(r.fs, mkPath("test", "project", "main.yaml"))
 				require.NoError(t, err)
 				assert.Equal(t, "manifest", string(c))
 
 				mod := `{
-	main: {
-		env:       ""
-		instance:  "instance"
-		name:      "module"
-		namespace: "default"
-		registry:  "registry"
-		type:      "kcl"
-		values: {
-			key: "value"
+	env: "test"
+	modules: {
+		main: {
+			instance:  "instance"
+			name:      "module"
+			namespace: "default"
+			registry:  "registry"
+			type:      "kcl"
+			values: {
+				key: "value"
+			}
+			version: "v1.0.0"
 		}
-		version: "v1.0.0"
 	}
 }`
-				c, err = afero.ReadFile(r.fs, mkPath("dev", "project", "mod.cue"))
+				c, err = afero.ReadFile(r.fs, mkPath("test", "project", "mod.cue"))
 				require.NoError(t, err)
 				assert.Equal(t, mod, string(c))
 
@@ -153,7 +158,8 @@ func TestDeployerDeploy(t *testing.T) {
 			project: newProject(
 				"project",
 				sp.ModuleBundle{
-					"main": {
+					Env: "test",
+					Modules: map[string]sp.Module{"main": {
 						Instance:  "instance",
 						Name:      "module",
 						Namespace: "default",
@@ -162,38 +168,39 @@ func TestDeployerDeploy(t *testing.T) {
 						Values:    map[string]string{"key": "value"},
 						Version:   "v1.0.0",
 					},
+					},
 				},
 			),
 			files: map[string]string{
-				mkPath("dev", "project", "extra.yaml"): "extra",
+				mkPath("test", "project", "extra.yaml"): "extra",
 			},
 			dryrun: true,
 			validate: func(t *testing.T, r testResult) {
 				require.NoError(t, r.err)
 
-				e, err := afero.Exists(r.fs, mkPath("dev", "project", "main.yaml"))
+				e, err := afero.Exists(r.fs, mkPath("test", "project", "main.yaml"))
 				require.NoError(t, err)
 				assert.True(t, e)
 
-				e, err = afero.Exists(r.fs, mkPath("dev", "project", "mod.cue"))
+				e, err = afero.Exists(r.fs, mkPath("test", "project", "mod.cue"))
 				require.NoError(t, err)
 				assert.True(t, e)
 
-				e, err = afero.Exists(r.fs, mkPath("dev", "project", "extra.yaml"))
+				e, err = afero.Exists(r.fs, mkPath("test", "project", "extra.yaml"))
 				require.NoError(t, err)
 				assert.False(t, e)
 
 				wt, err := r.repo.Worktree()
 				require.NoError(t, err)
 				st, err := wt.Status()
 				require.NoError(t, err)
-				fst := st.File("root/dev/project/extra.yaml")
+				fst := st.File("root/test/project/extra.yaml")
 				assert.Equal(t, fst.Staging, gg.Deleted)
 
-				fst = st.File("root/dev/project/main.yaml")
+				fst = st.File("root/test/project/main.yaml")
 				assert.Equal(t, fst.Staging, gg.Added)
 
-				fst = st.File("root/dev/project/mod.cue")
+				fst = st.File("root/test/project/mod.cue")
 				assert.Equal(t, fst.Staging, gg.Added)
 
 				head, err := r.repo.Head()
@@ -203,6 +210,30 @@ func TestDeployerDeploy(t *testing.T) {
 				assert.Equal(t, "initial commit", cm.Message)
 			},
 		},
+		{
+			name: "deploy to production",
+			project: newProject(
+				"project",
+				sp.ModuleBundle{
+					Env: "prod",
+					Modules: map[string]sp.Module{"main": {
+						Instance:  "instance",
+						Name:      "module",
+						Namespace: "default",
+						Registry:  "registry",
+						Type:      "kcl",
+						Values:    map[string]string{"key": "value"},
+						Version:   "v1.0.0",
+					},
+					},
+				},
+			),
+			files:  map[string]string{},
+			dryrun: true,
+			validate: func(t *testing.T, r testResult) {
+				assert.Error(t, r.err)
+			},
+		},
 	}
 
 	for _, tt := range tests {
@@ -248,7 +279,7 @@ func TestDeployerDeploy(t *testing.T) {
 					map[deployment.Provider]func(*slog.Logger) deployment.ManifestGenerator{
 						deployment.ProviderKCL: func(logger *slog.Logger) deployment.ManifestGenerator {
 							return &dm.ManifestGeneratorMock{
-								GenerateFunc: func(mod sp.Module) ([]byte, error) {
+								GenerateFunc: func(mod sp.Module, env string) ([]byte, error) {
 									return []byte("manifest"), nil
 								},
 							}

lib/project/deployment/generator/generator.go

@@ -40,9 +40,9 @@ func (d *Generator) GenerateBundle(b deployment.ModuleBundle, env cue.Value) (Ge
 	}
 
 	results := make(map[string][]byte)
-	for name, module := range nb.Bundle {
+	for name, module := range nb.Bundle.Modules {
 		d.logger.Debug("Generating module", "name", name)
-		result, err := d.Generate(module)
+		result, err := d.Generate(module, b.Bundle.Env)
 		if err != nil {
 			return GeneratorResult{}, fmt.Errorf("failed to generate module %s: %w", name, err)
 		}
@@ -57,7 +57,7 @@ func (d *Generator) GenerateBundle(b deployment.ModuleBundle, env cue.Value) (Ge
 }
 
 // Generate generates manifests for a deployment module.
-func (d *Generator) Generate(m sp.Module) ([]byte, error) {
+func (d *Generator) Generate(m sp.Module, env string) ([]byte, error) {
 	if err := deployment.Validate(m); err != nil {
 		return nil, fmt.Errorf("failed to validate module: %w", err)
 	}
@@ -67,7 +67,7 @@ func (d *Generator) Generate(m sp.Module) ([]byte, error) {
 		return nil, fmt.Errorf("failed to get generator for module: %w", err)
 	}
 
-	manifests, err := mg.Generate(m)
+	manifests, err := mg.Generate(m, env)
 	if err != nil {
 		return nil, fmt.Errorf("failed to generate manifest for module: %w", err)
 	}