Fix #1868: Fix flake handling (#1870)

## Summary
`devbox update` does not work with git flakes. This adds support for git
flake to `devbox update` and also ensures that the nix packages are
rebuilt when an update is requested. Without this, git flakes will not
be refreshed from git.

## How was it tested?

1. Configured a devbox.json with devbox packages and flakes
2. Ran devbox shell without a .devbox folder and without packages being
installed in nix
3. Saw packages get installed 
4. Ran devbox shell with a .devbox folder and with packages being
installed in nix
5. Saw packages verified, but not updated or installed
6. Ran devbox update
7. Saw packages get rebuild with `nix build --refresh`

---------

Signed-off-by: Greg Curtis <[email protected]>
Co-authored-by: Greg Curtis <[email protected]>

Author: kadaan

internal/devbox/packages.go

@@ -260,7 +260,7 @@ func (d *Devbox) ensureStateIsUpToDate(ctx context.Context, mode installMode) er
 	}
 
 	if mode == install || mode == update || mode == ensure {
-		if err := d.installPackages(ctx); err != nil {
+		if err := d.installPackages(ctx, mode); err != nil {
 			return err
 		}
 	}
@@ -384,15 +384,15 @@ func resetProfileDirForFlakes(profileDir string) (err error) {
 	return errors.WithStack(os.Remove(profileDir))
 }
 
-func (d *Devbox) installPackages(ctx context.Context) error {
+func (d *Devbox) installPackages(ctx context.Context, mode installMode) error {
 	// Create plugin directories first because packages might need them
 	for _, pluginConfig := range d.Config().IncludedPluginConfigs() {
 		if err := d.PluginManager().CreateFilesForConfig(pluginConfig); err != nil {
 			return err
 		}
 	}
 
-	if err := d.installNixPackagesToStore(ctx); err != nil {
+	if err := d.installNixPackagesToStore(ctx, mode); err != nil {
 		return err
 	}
 
@@ -420,8 +420,8 @@ func (d *Devbox) InstallRunXPackages(ctx context.Context) error {
 // This is done by running `nix build` on the flake. We do this so that the
 // packages will be available in the nix store when computing the devbox environment
 // and installing in the nix profile (even if offline).
-func (d *Devbox) installNixPackagesToStore(ctx context.Context) error {
-	packages, err := d.packagesToInstallInStore(ctx)
+func (d *Devbox) installNixPackagesToStore(ctx context.Context, mode installMode) error {
+	packages, err := d.packagesToInstallInStore(ctx, mode)
 	if err != nil {
 		return err
 	}
@@ -439,12 +439,17 @@ func (d *Devbox) installNixPackagesToStore(ctx context.Context) error {
 			return err
 		}
 
+		// --no-link to avoid generating the result objects
+		flags := []string{"--no-link"}
+		if mode == update {
+			flags = append(flags, "--refresh")
+		}
+
 		for _, installable := range installables {
 			args := &nix.BuildArgs{
 				AllowInsecure: pkg.HasAllowInsecure(),
-				// --no-link to avoid generating the result objects
-				Flags:  []string{"--no-link"},
-				Writer: d.stderr,
+				Flags:         flags,
+				Writer:        d.stderr,
 			}
 			err = nix.Build(ctx, args, installable)
 			if err != nil {
@@ -460,7 +465,7 @@ func (d *Devbox) installNixPackagesToStore(ctx context.Context) error {
 	return err
 }
 
-func (d *Devbox) packagesToInstallInStore(ctx context.Context) ([]*devpkg.Package, error) {
+func (d *Devbox) packagesToInstallInStore(ctx context.Context, mode installMode) ([]*devpkg.Package, error) {
 	// First, get and prepare all the packages that must be installed in this project
 	// and remove non-nix packages from the list
 	packages := lo.Filter(d.InstallablePackages(), devpkg.IsNix)
@@ -476,6 +481,10 @@ func (d *Devbox) packagesToInstallInStore(ctx context.Context) ([]*devpkg.Packag
 			return nil, err
 		}
 		for _, installable := range installables {
+			if mode == update {
+				packagesToInstall = append(packagesToInstall, pkg)
+				continue
+			}
 			storePaths, err := nix.StorePathsFromInstallable(ctx, installable, pkg.HasAllowInsecure())
 			if err != nil {
 				return nil, packageInstallErrorHandler(err, pkg, installable)

internal/devbox/update.go

@@ -102,6 +102,9 @@ func (d *Devbox) updateDevboxPackage(pkg *devpkg.Package) error {
 	if err != nil {
 		return err
 	}
+	if resolved == nil {
+		return nil
+	}
 
 	return d.mergeResolvedPackageToLockfile(pkg, resolved, d.lockfile)
 }

internal/devpkg/package.go

@@ -142,7 +142,7 @@ func newPackage(raw string, isInstallable func() bool, locker lock.Locker) *Pack
 	// ("nixpkgs" is a devbox package and a flake). When that happens, we
 	// assume a Devbox package.
 	parsed, err := flake.ParseInstallable(raw)
-	if err != nil || isAmbiguous(raw, parsed) {
+	if err != nil || pkgtype.IsAmbiguous(raw, parsed) {
 		pkg.IsDevboxPackage = true
 		pkg.resolve = sync.OnceValue(func() error { return resolve(pkg) })
 		return pkg
@@ -156,38 +156,6 @@ func newPackage(raw string, isInstallable func() bool, locker lock.Locker) *Pack
 	return pkg
 }
 
-// isAmbiguous returns true if a package string could be a Devbox package or
-// a flake installable. For example, "nixpkgs" is both a Devbox package and a
-// flake.
-func isAmbiguous(raw string, parsed flake.Installable) bool {
-	// Devbox package strings never have a #attr_path in them.
-	if parsed.AttrPath != "" {
-		return false
-	}
-
-	// Indirect installables must have a "flake:" scheme to disambiguate
-	// them from legacy (unversioned) devbox package strings.
-	if parsed.Ref.Type == flake.TypeIndirect {
-		return !strings.HasPrefix(raw, "flake:")
-	}
-
-	// Path installables must have a "path:" scheme, start with "/" or start
-	// with "./" to disambiguate them from devbox package strings.
-	if parsed.Ref.Type == flake.TypePath {
-		if raw[0] == '.' || raw[0] == '/' {
-			return false
-		}
-		if strings.HasPrefix(raw, "path:") {
-			return false
-		}
-		return true
-	}
-
-	// All other flakeref types must have a scheme, so we know those can't
-	// be devbox package strings.
-	return false
-}
-
 // resolve is the implementation of Package.resolve, where it is wrapped in a
 // sync.OnceValue function. It should not be called directly.
 func resolve(pkg *Package) error {
@@ -242,7 +210,7 @@ func (p *Package) FlakeInputName() string {
 			}
 		}
 	default:
-		result = p.installable.String() + "-" + p.Hash()
+		result = p.installable.Ref.String() + "-" + p.Hash()
 	}
 
 	// replace all non-alphanumeric with dashes

internal/devpkg/pkgtype/flake.go

@@ -0,0 +1,53 @@
+package pkgtype
+
+import (
+	"strings"
+
+	"go.jetpack.io/devbox/nix/flake"
+)
+
+func IsFlake(s string) bool {
+	if IsRunX(s) {
+		return false
+	}
+	parsed, err := flake.ParseInstallable(s)
+	if err != nil {
+		return false
+	}
+	if IsAmbiguous(s, parsed) {
+		return false
+	}
+	return true
+}
+
+// IsAmbiguous returns true if a package string could be a Devbox package or
+// a flake installable. For example, "nixpkgs" is both a Devbox package and a
+// flake.
+func IsAmbiguous(raw string, parsed flake.Installable) bool {
+	// Devbox package strings never have a #attr_path in them.
+	if parsed.AttrPath != "" {
+		return false
+	}
+
+	// Indirect installables must have a "flake:" scheme to disambiguate
+	// them from legacy (unversioned) devbox package strings.
+	if parsed.Ref.Type == flake.TypeIndirect {
+		return !strings.HasPrefix(raw, "flake:")
+	}
+
+	// Path installables must have a "path:" scheme, start with "/" or start
+	// with "./" to disambiguate them from devbox package strings.
+	if parsed.Ref.Type == flake.TypePath {
+		if raw[0] == '.' || raw[0] == '/' {
+			return false
+		}
+		if strings.HasPrefix(raw, "path:") {
+			return false
+		}
+		return true
+	}
+
+	// All other flakeref types must have a scheme, so we know those can't
+	// be devbox package strings.
+	return false
+}

internal/lock/resolve.go

@@ -28,6 +28,10 @@ import (
 // a newer hash than the lock file but same version. In that case we don't want
 // to update because it would be slow and wasteful.
 func (f *File) FetchResolvedPackage(pkg string) (*Package, error) {
+	if pkgtype.IsFlake(pkg) {
+		return nil, nil
+	}
+
 	name, version, _ := searcher.ParseVersionedPackage(pkg)
 	if version == "" {
 		return nil, usererr.New("No version specified for %q.", name)