[refactor] intro nixprofile package (#1238)

## Summary

There are three motivations for introducing the `nixprofile` package:

1. We should keep `nix` package focussed on executing core nix apis.
This would
reduce its dependencies on other packages, enabling more packages to
call `nix`
functions without hitting cycle errors.

`nixprofile` has a lot of devbox-specific logic. So, it should be its
own package that calls `nix` apis (which themselves can be improved)

2. I tried moving `nix.Package` to `devpkg` but it was extremely
difficult to avoid
new cyclic import errors. This PR will help avoid those.

3. This will also help break the import cycle for calling `nix.System`
from `lock.Lockfile`.

## How was it tested?

compiles

- [x] testscript should pass

Author: savil

internal/impl/packages.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/samber/lo"
+	"go.jetpack.io/devbox/internal/nix/nixprofile"
 	"go.jetpack.io/devbox/internal/shellgen"
 	"golang.org/x/exp/slices"
 
@@ -276,7 +277,7 @@ func (d *Devbox) addPackagesToProfile(ctx context.Context, mode installMode) err
 
 		stepMsg := fmt.Sprintf("[%d/%d] %s", stepNum, total, pkg)
 
-		if err := nix.ProfileInstall(&nix.ProfileInstallArgs{
+		if err := nixprofile.ProfileInstall(&nixprofile.ProfileInstallArgs{
 			CustomStepMessage: stepMsg,
 			Lockfile:          d.lockfile,
 			Package:           pkg,
@@ -299,7 +300,7 @@ func (d *Devbox) removePackagesFromProfile(ctx context.Context, pkgs []string) e
 	}
 
 	for _, input := range nix.PackageFromStrings(pkgs, d.lockfile) {
-		index, err := nix.ProfileListIndex(&nix.ProfileListIndexArgs{
+		index, err := nixprofile.ProfileListIndex(&nixprofile.ProfileListIndexArgs{
 			Lockfile:   d.lockfile,
 			Writer:     d.writer,
 			Input:      input,
@@ -345,7 +346,7 @@ func (d *Devbox) tidyProfile(ctx context.Context) error {
 	}
 
 	// Remove by index to avoid comparing nix.ProfileListItem <> nix.Inputs again.
-	return nix.ProfileRemoveItems(profileDir, extras)
+	return nixprofile.ProfileRemoveItems(profileDir, extras)
 }
 
 // pendingPackagesForInstallation returns a list of packages that are in
@@ -361,12 +362,12 @@ func (d *Devbox) pendingPackagesForInstallation(ctx context.Context) ([]string,
 	}
 
 	pending := []string{}
-	list, err := nix.ProfileListItems(d.writer, profileDir)
+	list, err := nixprofile.ProfileListItems(d.writer, profileDir)
 	if err != nil {
 		return nil, err
 	}
 	for _, input := range d.PackagesAsInputs() {
-		_, err := nix.ProfileListIndex(&nix.ProfileListIndexArgs{
+		_, err := nixprofile.ProfileListIndex(&nixprofile.ProfileListIndexArgs{
 			List:       list,
 			Lockfile:   d.lockfile,
 			Writer:     d.writer,
@@ -388,15 +389,15 @@ func (d *Devbox) pendingPackagesForInstallation(ctx context.Context) ([]string,
 //
 // NOTE: as an optimization, this implementation assumes that all packages in
 // devbox.json have already been added to the nix profile.
-func (d *Devbox) extraPackagesInProfile(ctx context.Context) ([]*nix.NixProfileListItem, error) {
+func (d *Devbox) extraPackagesInProfile(ctx context.Context) ([]*nixprofile.NixProfileListItem, error) {
 	defer trace.StartRegion(ctx, "extraPackagesInProfile").End()
 
 	profileDir, err := d.profilePath()
 	if err != nil {
 		return nil, err
 	}
 
-	profileItems, err := nix.ProfileListItems(d.writer, profileDir)
+	profileItems, err := nixprofile.ProfileListItems(d.writer, profileDir)
 	if err != nil {
 		return nil, err
 	}
@@ -409,12 +410,12 @@ func (d *Devbox) extraPackagesInProfile(ctx context.Context) ([]*nix.NixProfileL
 		return nil, nil
 	}
 
-	extras := []*nix.NixProfileListItem{}
+	extras := []*nixprofile.NixProfileListItem{}
 	// Note: because nix.Input uses memoization when normalizing attribute paths (slow operation),
 	// and since we're reusing the Input objects, this O(n*m) loop becomes O(n+m) wrt the slow operation.
 outer:
 	for _, item := range profileItems {
-		profileInput := nix.PackageFromProfileItem(item, d.lockfile)
+		profileInput := item.ToPackage(d.lockfile)
 		for _, devboxInput := range devboxInputs {
 			if profileInput.Equals(devboxInput) {
 				continue outer

internal/impl/update.go

@@ -9,6 +9,7 @@ import (
 
 	"go.jetpack.io/devbox/internal/devpkg"
 	"go.jetpack.io/devbox/internal/nix"
+	"go.jetpack.io/devbox/internal/nix/nixprofile"
 	"go.jetpack.io/devbox/internal/searcher"
 	"go.jetpack.io/devbox/internal/shellgen"
 	"go.jetpack.io/devbox/internal/ux"
@@ -120,7 +121,7 @@ func (d *Devbox) attemptToUpgradeFlake(pkg *nix.Package) error {
 		pkg.Raw,
 	)
 
-	err = nix.ProfileUpgrade(profilePath, pkg, d.lockfile)
+	err = nixprofile.ProfileUpgrade(profilePath, pkg, d.lockfile)
 	if err != nil {
 		ux.Ferror(
 			d.writer,

internal/impl/util.go

@@ -9,8 +9,8 @@ import (
 	"path/filepath"
 
 	"github.com/pkg/errors"
+	"go.jetpack.io/devbox/internal/nix/nixprofile"
 
-	"go.jetpack.io/devbox/internal/nix"
 	"go.jetpack.io/devbox/internal/xdg"
 )
 
@@ -24,7 +24,7 @@ func (d *Devbox) addDevboxUtilityPackage(pkg string) error {
 		return err
 	}
 
-	return nix.ProfileInstall(&nix.ProfileInstallArgs{
+	return nixprofile.ProfileInstall(&nixprofile.ProfileInstallArgs{
 		Lockfile:    d.lockfile,
 		Package:     pkg,
 		ProfilePath: profilePath,

internal/nix/command.go

@@ -0,0 +1,17 @@
+package nix
+
+import (
+	"os"
+	"os/exec"
+)
+
+func command(args ...string) *exec.Cmd {
+
+	cmd := exec.Command("nix", args...)
+	cmd.Args = append(cmd.Args, ExperimentalFlags()...)
+	return cmd
+}
+
+func allowUnfreeEnv() []string {
+	return append(os.Environ(), "NIXPKGS_ALLOW_UNFREE=1")
+}

internal/nix/input.go

@@ -77,12 +77,6 @@ func PackageFromString(raw string, locker lock.Locker) *Package {
 	return &Package{*pkgURL, locker, raw, ""}
 }
 
-// PackageFromProfileItem constructs a package using the the unlocked reference
-// from profile list item.
-func PackageFromProfileItem(item *NixProfileListItem, locker lock.Locker) *Package {
-	return PackageFromString(item.unlockedReference, locker)
-}
-
 // isLocal specifies whether this package is a local flake.
 // Usually, this is of the form: `path:./local_flake_subdir#myPackage`
 func (p *Package) isLocal() bool {
@@ -165,7 +159,7 @@ func (p *Package) URLForInstall() (string, error) {
 	return p.urlWithoutFragment() + "#" + attrPath, nil
 }
 
-func (p *Package) normalizedDevboxPackageReference() (string, error) {
+func (p *Package) NormalizedDevboxPackageReference() (string, error) {
 	if !p.isDevboxPackage() {
 		return "", nil
 	}
@@ -213,7 +207,7 @@ func (p *Package) PackageAttributePath() (string, error) {
 // it is much faster than NormalizedPackageAttributePath
 func (p *Package) FullPackageAttributePath() (string, error) {
 	if p.isDevboxPackage() {
-		reference, err := p.normalizedDevboxPackageReference()
+		reference, err := p.NormalizedDevboxPackageReference()
 		if err != nil {
 			return "", err
 		}
@@ -383,11 +377,11 @@ func (p *Package) LegacyToVersioned() string {
 }
 
 func (p *Package) EnsureNixpkgsPrefetched(w io.Writer) error {
-	hash := p.hashFromNixPkgsURL()
+	hash := p.HashFromNixPkgsURL()
 	if hash == "" {
 		return nil
 	}
-	return ensureNixpkgsPrefetched(w, hash)
+	return EnsureNixpkgsPrefetched(w, hash)
 }
 
 // version returns the version of the package
@@ -404,7 +398,7 @@ func (p *Package) isVersioned() bool {
 	return p.isDevboxPackage() && strings.Contains(p.Path, "@")
 }
 
-func (p *Package) hashFromNixPkgsURL() string {
+func (p *Package) HashFromNixPkgsURL() string {
 	return HashFromNixPkgsURL(p.URLForFlakeInput())
 }
 

internal/nix/nixpkgs.go

@@ -19,8 +19,8 @@ import (
 	"go.jetpack.io/devbox/internal/xdg"
 )
 
-// ensureNixpkgsPrefetched runs the prefetch step to download the flake of the registry
-func ensureNixpkgsPrefetched(w io.Writer, commit string) error {
+// EnsureNixpkgsPrefetched runs the prefetch step to download the flake of the registry
+func EnsureNixpkgsPrefetched(w io.Writer, commit string) error {
 	// Look up the cached map of commitHash:nixStoreLocation
 	commitToLocation, err := nixpkgsCommitFileContents()
 	if err != nil {