Merge pull request #87 from nebari-dev/single-server-model

refactor: replace multi-server model with single-server model

Author: Adam-D-Lewis

cmd/nebi/client.go

@@ -9,45 +9,37 @@ import (
 	"time"
 
 	"github.com/nebari-dev/nebi/internal/cliclient"
-	"github.com/nebari-dev/nebi/internal/localstore"
+	"github.com/nebari-dev/nebi/internal/store"
 )
 
 // ErrWsNotFound is returned when a workspace name is not found on the server.
 var ErrWsNotFound = errors.New("workspace not found on server")
 
-// resolveServerFlag returns the server argument, falling back to the default server from config.
-func resolveServerFlag(serverArg string) (string, error) {
-	if serverArg != "" {
-		return serverArg, nil
-	}
-	cfg, err := localstore.LoadConfig()
+// getAuthenticatedClient loads credentials and returns an authenticated API client.
+func getAuthenticatedClient() (*cliclient.Client, error) {
+	s, err := store.New()
 	if err != nil {
-		return "", fmt.Errorf("loading config: %w", err)
-	}
-	if cfg.DefaultServer == "" {
-		return "", fmt.Errorf("no server specified; use -s <server> or set a default with 'nebi server set-default <name>'")
+		return nil, err
 	}
-	return cfg.DefaultServer, nil
-}
+	defer s.Close()
 
-// getAuthenticatedClient resolves a server name or URL, loads credentials, and returns an authenticated API client.
-func getAuthenticatedClient(serverArg string) (*cliclient.Client, error) {
-	serverURL, err := resolveServerURL(serverArg)
+	serverURL, err := s.LoadServerURL()
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("loading server URL: %w", err)
+	}
+	if serverURL == "" {
+		return nil, fmt.Errorf("no server configured; run 'nebi login <server-url>' first")
 	}
 
-	creds, err := localstore.LoadCredentials()
+	creds, err := s.LoadCredentials()
 	if err != nil {
 		return nil, fmt.Errorf("loading credentials: %w", err)
 	}
-
-	cred, ok := creds.Servers[serverURL]
-	if !ok {
-		return nil, fmt.Errorf("not logged in to %s; run 'nebi login %s' first", serverURL, serverArg)
+	if creds.Token == "" {
+		return nil, fmt.Errorf("not logged in; run 'nebi login <server-url>' first")
 	}
 
-	return cliclient.New(serverURL, cred.Token), nil
+	return cliclient.New(serverURL, creds.Token), nil
 }
 
 // findWsByName searches for a workspace by name on the server.
@@ -66,16 +58,6 @@ func findWsByName(client *cliclient.Client, ctx context.Context, name string) (*
 	return nil, fmt.Errorf("%w: %q", ErrWsNotFound, name)
 }
 
-// findGlobalWorkspaceByName looks up a global workspace by name in the local index.
-func findGlobalWorkspaceByName(idx *localstore.Index, name string) *localstore.Workspace {
-	for _, ws := range idx.Workspaces {
-		if ws.Name == name && ws.Global {
-			return ws
-		}
-	}
-	return nil
-}
-
 // validateWorkspaceName checks that a workspace name doesn't contain path separators or colons,
 // which would make it ambiguous with paths or server refs.
 func validateWorkspaceName(name string) error {
@@ -91,74 +73,64 @@ func validateWorkspaceName(name string) error {
 	return nil
 }
 
-// lookupOrigin returns the origin for the current working directory and the given server.
-// Returns nil (no error) if no origin is set.
-func lookupOrigin(server string) (*localstore.Origin, error) {
+// lookupOrigin returns the origin fields for the current working directory workspace.
+// Returns nil (no error) if no workspace is tracked or no origin is set.
+func lookupOrigin() (*store.LocalWorkspace, error) {
 	cwd, err := os.Getwd()
 	if err != nil {
 		return nil, fmt.Errorf("getting working directory: %w", err)
 	}
 
-	store, err := localstore.NewStore()
+	s, err := store.New()
 	if err != nil {
 		return nil, err
 	}
+	defer s.Close()
 
-	idx, err := store.LoadIndex()
+	ws, err := s.FindWorkspaceByPath(cwd)
 	if err != nil {
 		return nil, err
 	}
-
-	ws, exists := idx.Workspaces[cwd]
-	if !exists || ws.Origins == nil {
+	if ws == nil || ws.OriginName == "" {
 		return nil, nil
 	}
 
-	return ws.Origins[server], nil
+	return ws, nil
 }
 
 // saveOrigin records a push/pull origin for the current working directory.
-func saveOrigin(server, name, tag, action, tomlContent, lockContent string) error {
+func saveOrigin(name, tag, action, tomlContent, lockContent string) error {
 	cwd, err := os.Getwd()
 	if err != nil {
 		return fmt.Errorf("getting working directory: %w", err)
 	}
 
-	store, err := localstore.NewStore()
+	s, err := store.New()
 	if err != nil {
 		return err
 	}
+	defer s.Close()
 
-	idx, err := store.LoadIndex()
+	ws, err := s.FindWorkspaceByPath(cwd)
 	if err != nil {
 		return err
 	}
-
-	ws, exists := idx.Workspaces[cwd]
-	if !exists {
-		// Not a tracked workspace — nothing to save
+	if ws == nil {
 		return nil
 	}
 
-	if ws.Origins == nil {
-		ws.Origins = make(map[string]*localstore.Origin)
-	}
-
-	tomlHash, err := localstore.TomlContentHash(tomlContent)
+	tomlHash, err := store.TomlContentHash(tomlContent)
 	if err != nil {
 		return fmt.Errorf("hashing pixi.toml: %w", err)
 	}
 
-	ws.Origins[server] = &localstore.Origin{
-		Name:      name,
-		Tag:       tag,
-		Action:    action,
-		TomlHash:  tomlHash,
-		LockHash:  localstore.ContentHash(lockContent),
-		Timestamp: time.Now().UTC().Format("2006-01-02T15:04:05Z"),
-	}
+	ws.OriginName = name
+	ws.OriginTag = tag
+	ws.OriginAction = action
+	ws.OriginTomlHash = tomlHash
+	ws.OriginLockHash = store.ContentHash(lockContent)
 
-	return store.SaveIndex(idx)
+	return s.SaveWorkspace(ws)
 }
 
 // parseWsRef parses a reference in the format workspace:tag.

cmd/nebi/diff.go

@@ -9,12 +9,11 @@ import (
 
 	"github.com/nebari-dev/nebi/internal/cliclient"
 	"github.com/nebari-dev/nebi/internal/diff"
-	"github.com/nebari-dev/nebi/internal/localstore"
+	"github.com/nebari-dev/nebi/internal/store"
 	"github.com/spf13/cobra"
 )
 
 var diffLock bool
-var diffServer string
 
 var diffCmd = &cobra.Command{
 	Use:   "diff <ref-a> [ref-b] [--lock]",
@@ -26,26 +25,25 @@ Each reference can be:
   - A server ref (contains a colon): myworkspace:v1
 
 If no refs are given, compares the current directory against the last
-pushed/pulled origin on the target server.
+pushed/pulled origin.
 
 If only one ref is given, it is compared against the current directory.
 
 Examples:
-  nebi diff                                    # local vs origin on server
+  nebi diff                                    # local vs origin
   nebi diff ./other-project                    # other dir vs cwd
   nebi diff ./project-a ./project-b            # two local dirs
   nebi diff data-science                       # global workspace vs cwd
-  nebi diff myworkspace:v1 -s work             # server version vs cwd
-  nebi diff myworkspace:v1 myworkspace:v2 -s work  # two server versions
-  nebi diff myworkspace:v1 ./local-dir -s work # server vs local dir
+  nebi diff myworkspace:v1                     # server version vs cwd
+  nebi diff myworkspace:v1 myworkspace:v2      # two server versions
+  nebi diff myworkspace:v1 ./local-dir         # server vs local dir
 
 Use --lock to also compare pixi.lock files.`,
 	Args: cobra.RangeArgs(0, 2),
 	RunE: runDiff,
 }
 
 func init() {
-	diffCmd.Flags().StringVarP(&diffServer, "server", "s", "", "Server name or URL (uses default if not set)")
 	diffCmd.Flags().BoolVar(&diffLock, "lock", false, "Also diff pixi.lock files")
 }
 
@@ -62,18 +60,14 @@ func runDiff(cmd *cobra.Command, args []string) error {
 	switch len(args) {
 	case 0:
 		// No args — diff origin vs local (origin is baseline, local shows changes)
-		server, err := resolveServerFlag(diffServer)
-		if err != nil {
-			return err
-		}
-		origin, err := lookupOrigin(server)
+		origin, err := lookupOrigin()
 		if err != nil {
 			return err
 		}
 		if origin == nil {
 			return fmt.Errorf("no origin set; use 'nebi diff <ref>' or push/pull first")
 		}
-		refA = origin.Name + ":" + origin.Tag
+		refA = origin.OriginName + ":" + origin.OriginTag
 		refB = "."
 	case 1:
 		refA = "."
@@ -150,15 +144,14 @@ func resolveSource(ref, defaultLabel string) (*diffSource, error) {
 		return resolveLocalSource(ref, defaultLabel)
 	}
 
-	// 2. Global workspace name (check index before assuming server ref)
+	// 2. Global workspace name (check store before assuming server ref)
 	if !strings.Contains(ref, ":") {
-		store, err := localstore.NewStore()
+		s, err := store.New()
 		if err == nil {
-			idx, err := store.LoadIndex()
-			if err == nil {
-				if ws := findGlobalWorkspaceByName(idx, ref); ws != nil {
-					return resolveLocalSource(ws.Path, ref)
-				}
+			defer s.Close()
+			ws, err := s.FindGlobalWorkspaceByName(ref)
+			if err == nil && ws != nil {
+				return resolveLocalSource(ws.Path, ref)
 			}
 		}
 	}
@@ -201,12 +194,7 @@ func resolveLocalSource(dir, defaultLabel string) (*diffSource, error) {
 func resolveServerSource(ref string) (*diffSource, error) {
 	wsName, tag := parseWsRef(ref)
 
-	server, err := resolveServerFlag(diffServer)
-	if err != nil {
-		return nil, err
-	}
-
-	client, err := getAuthenticatedClient(server)
+	client, err := getAuthenticatedClient()
 	if err != nil {
 		return nil, err
 	}
@@ -273,7 +261,7 @@ func resolveVersionNumber(client *cliclient.Client, ctx context.Context, wsID, w
 	return latest.VersionNumber, nil
 }
 
-// isPath returns true if ref looks like a filesystem path (contains a path separator or is "." or "..").
+// isPath returns true if ref looks like a filesystem path.
 func isPath(ref string) bool {
 	return ref == "." || ref == ".." || strings.Contains(ref, "/") || strings.Contains(ref, string(filepath.Separator))
 }