feat: adds support for fetching bundles from git (#152)

Author: jmgilman

lib/project/deployment/deployer/deployer.go

@@ -6,6 +6,7 @@ import (
 	"path/filepath"
 
 	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/cuecontext"
 	"github.com/input-output-hk/catalyst-forge/lib/project/deployment"
 	"github.com/input-output-hk/catalyst-forge/lib/project/deployment/generator"
 	"github.com/input-output-hk/catalyst-forge/lib/project/project"
@@ -95,17 +96,17 @@ type Deployer struct {
 	ss     secrets.SecretStore
 }
 
-// PrepareOptions are options for preparing a deployment.
-type PrepareOptions struct {
+// CloneOptions are options for cloning a repository.
+type CloneOptions struct {
 	fs fs.Filesystem
 }
 
-// PrepareOption is an option for preparing a deployment.
-type PrepareOption func(*PrepareOptions)
+// CloneOption is an option for cloning a repository.
+type CloneOption func(*CloneOptions)
 
-// WithFS sets the filesystem to use for preparing a deployment.
-func WithFS(fs fs.Filesystem) PrepareOption {
-	return func(o *PrepareOptions) {
+// WithFS sets the filesystem to use for cloning a repository.
+func WithFS(fs fs.Filesystem) CloneOption {
+	return func(o *CloneOptions) {
 		o.fs = fs
 	}
 }
@@ -114,9 +115,9 @@ func WithFS(fs fs.Filesystem) PrepareOption {
 func (d *Deployer) CreateDeployment(
 	project string,
 	bundle deployment.ModuleBundle,
-	opts ...PrepareOption,
+	opts ...CloneOption,
 ) (*Deployment, error) {
-	options := PrepareOptions{
+	options := CloneOptions{
 		fs: billy.NewInMemoryFs(),
 	}
 	for _, o := range opts {
@@ -181,6 +182,40 @@ func (d *Deployer) CreateDeployment(
 	}, nil
 }
 
+// FetchBundle fetches a deployment bundle from the given project and repository.
+func (d *Deployer) FetchBundle(url, ref, projectPath string, opts ...CloneOption) (deployment.ModuleBundle, error) {
+	options := CloneOptions{
+		fs: billy.NewInMemoryFs(),
+	}
+	for _, o := range opts {
+		o(&options)
+	}
+
+	r, err := d.clone(url, ref, options.fs)
+	if err != nil {
+		return deployment.ModuleBundle{}, err
+	}
+
+	exists, err := r.Exists(projectPath)
+	if err != nil {
+		return deployment.ModuleBundle{}, fmt.Errorf("could not check if project path exists: %w", err)
+	} else if !exists {
+		return deployment.ModuleBundle{}, fmt.Errorf("project path does not exist: %s", projectPath)
+	}
+
+	loader := project.NewDefaultProjectLoader(cuecontext.New(), d.ss, d.logger, project.WithFs(r.WorkFs()))
+	p, err := loader.Load("/" + projectPath)
+	if err != nil {
+		return deployment.ModuleBundle{}, fmt.Errorf("could not load project: %w", err)
+	}
+
+	if p.Blueprint.Project == nil || p.Blueprint.Project.Deployment == nil {
+		return deployment.ModuleBundle{}, fmt.Errorf("project does not have a deployment bundle")
+	}
+
+	return deployment.NewModuleBundle(&p), nil
+}
+
 // Commit commits the deployment to the GitOps repository.
 func (d *Deployment) Commit() error {
 	d.logger.Info("Committing changes")

lib/project/deployment/deployer/deployer_test.go

@@ -20,6 +20,76 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestDeployerFetchBundle(t *testing.T) {
+	tests := []struct {
+		name     string
+		cfg      DeployerConfig
+		files    map[string]string
+		validate func(*testing.T, deployment.ModuleBundle, error)
+	}{
+		{
+			name: "success",
+			cfg:  makeConfig(),
+			files: map[string]string{
+				"project/blueprint.cue": makeBlueprint(),
+			},
+			validate: func(t *testing.T, bundle deployment.ModuleBundle, err error) {
+				require.NoError(t, err)
+
+				b := bundle.Bundle
+				assert.Equal(t, "test", b.Env)
+				assert.Len(t, b.Modules, 1)
+				assert.Equal(t, "module", b.Modules["main"].Name)
+				assert.Equal(t, "v1.0.0", b.Modules["main"].Version)
+			},
+		},
+		{
+			name: "no bundle",
+			cfg:  makeConfig(),
+			files: map[string]string{
+				"project/blueprint.cue": `version: "1.0"`,
+			},
+			validate: func(t *testing.T, bundle deployment.ModuleBundle, err error) {
+				require.Error(t, err)
+				require.Equal(t, "project does not have a deployment bundle", err.Error())
+			},
+		},
+		{
+			name: "no project",
+			cfg:  makeConfig(),
+			files: map[string]string{
+				"project1/blueprint.cue": `version: "1.0"`,
+			},
+			validate: func(t *testing.T, bundle deployment.ModuleBundle, err error) {
+				require.Error(t, err)
+				require.Equal(t, "project path does not exist: project", err.Error())
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fs := billy.NewInMemoryFs()
+
+			remote, _, err := tu.NewMockGitRemoteInterface(tt.files)
+			require.NoError(t, err)
+
+			ss := tu.NewMockSecretStore(map[string]string{"token": "password"})
+			d := Deployer{
+				cfg:    tt.cfg,
+				ctx:    cuecontext.New(),
+				fs:     fs,
+				logger: testutils.NewNoopLogger(),
+				remote: remote,
+				ss:     ss,
+			}
+
+			bundle, err := d.FetchBundle("github.com/org/repo", "main", "project")
+			tt.validate(t, bundle, err)
+		})
+	}
+}
+
 func TestDeployerCreateDeployment(t *testing.T) {
 	type testResult struct {
 		cloneOpts *gg.CloneOptions
@@ -241,3 +311,42 @@ func makeConfig() DeployerConfig {
 		RootDir: "root",
 	}
 }
+
+func makeBlueprint() string {
+	return `
+		{
+			version: "1.0"
+			project: {
+				name: "project"
+				deployment: {
+					on: {}
+					bundle: {
+						env: "test"
+						modules: {
+							main: {
+								name: "module"
+								version: "v1.0.0"
+								values: {
+									foo: "bar"
+								}
+							}
+						}
+					}
+				}
+			}
+			global: {
+				deployment: {
+					registries: {
+						containers: "registry.com"
+						modules: "registry.com"
+					}
+					repo: {
+						ref: "main"
+						url: "github.com/org/repo"
+					}
+					root: "root"
+				}
+			}
+		}
+	`
+}

lib/project/project/loader.go

@@ -29,6 +29,29 @@ type ProjectLoader interface {
 	Load(projectPath string) (Project, error)
 }
 
+type ProjectLoaderOption func(*DefaultProjectLoader)
+
+// WithFs sets the filesystem for the project loader.
+func WithFs(fs fs.Filesystem) ProjectLoaderOption {
+	return func(p *DefaultProjectLoader) {
+		p.fs = fs
+	}
+}
+
+// WithInjectors sets the blueprint injectors for the project loader.
+func WithInjectors(injectors []injector.BlueprintInjector) ProjectLoaderOption {
+	return func(p *DefaultProjectLoader) {
+		p.injectors = injectors
+	}
+}
+
+// WithRuntimes sets the runtime data for the project loader.
+func WithRuntimes(runtimes []RuntimeData) ProjectLoaderOption {
+	return func(p *DefaultProjectLoader) {
+		p.runtimes = runtimes
+	}
+}
+
 // DefaultProjectLoader is the default implementation of the ProjectLoader.
 type DefaultProjectLoader struct {
 	blueprintLoader blueprint.BlueprintLoader
@@ -204,6 +227,7 @@ func NewDefaultProjectLoader(
 	ctx *cue.Context,
 	store secrets.SecretStore,
 	logger *slog.Logger,
+	opts ...ProjectLoaderOption,
 ) DefaultProjectLoader {
 	if logger == nil {
 		logger = slog.New(slog.NewTextHandler(io.Discard, nil))
@@ -214,11 +238,9 @@ func NewDefaultProjectLoader(
 	}
 
 	fs := billy.NewBaseOsFS()
-	bl := blueprint.NewDefaultBlueprintLoader(ctx, logger)
-	return DefaultProjectLoader{
-		blueprintLoader: &bl,
-		ctx:             ctx,
-		fs:              fs,
+	l := DefaultProjectLoader{
+		ctx: ctx,
+		fs:  fs,
 		injectors: []injector.BlueprintInjector{
 			injector.NewBlueprintEnvInjector(ctx, logger),
 			injector.NewBlueprintGlobalInjector(ctx, logger),
@@ -230,31 +252,15 @@ func NewDefaultProjectLoader(
 		},
 		store: store,
 	}
-}
 
-// NewCustomProjectLoader creates a new DefaultProjectLoader with custom dependencies.
-func NewCustomProjectLoader(
-	ctx *cue.Context,
-	fs fs.Filesystem,
-	bl blueprint.BlueprintLoader,
-	injectors []injector.BlueprintInjector,
-	runtimes []RuntimeData,
-	store secrets.SecretStore,
-	logger *slog.Logger,
-) DefaultProjectLoader {
-	if logger == nil {
-		logger = slog.New(slog.NewTextHandler(io.Discard, nil))
+	for _, o := range opts {
+		o(&l)
 	}
 
-	return DefaultProjectLoader{
-		blueprintLoader: bl,
-		ctx:             ctx,
-		fs:              fs,
-		injectors:       injectors,
-		logger:          logger,
-		runtimes:        runtimes,
-		store:           store,
-	}
+	bl := blueprint.NewCustomBlueprintLoader(ctx, l.fs, logger)
+	l.blueprintLoader = &bl
+
+	return l
 }
 
 // validateAndDecode validates and decodes a raw blueprint.

lib/tools/git/repo/repo.go

@@ -157,6 +157,11 @@ func (g *GitRepo) GetCurrentTag() (string, error) {
 	return tag, nil
 }
 
+// GitFs returns the filesystem for the .git directory.
+func (g *GitRepo) GitFs() fs.Filesystem {
+	return g.gfs
+}
+
 // HasChanges returns true if the repository has changes.
 func (g *GitRepo) HasChanges() (bool, error) {
 	status, err := g.worktree.Status()
@@ -300,6 +305,11 @@ func (g *GitRepo) UnstageFile(path string) error {
 	return nil
 }
 
+// WorkFs returns the filesystem for the working directory.
+func (g *GitRepo) WorkFs() fs.Filesystem {
+	return g.wfs
+}
+
 // WriteFile writes the given contents to the given path in the repository.
 // It also automatically adds the file to the staging area.
 func (g *GitRepo) WriteFile(path string, contents []byte) error {