kandev/apps/backend/internal/linear/copy.go

package linear

import (
	"context"
	"errors"
	"fmt"
	"time"
)

// ErrSameWorkspace is returned when a copy targets the same workspace it reads
// from.
var ErrSameWorkspace = errors.New("linear: source and target workspaces are the same")

// ErrNothingToCopy is returned when the source workspace has no Linear config.
var ErrNothingToCopy = errors.New("linear: source workspace has no configuration to copy")

// CopyConfigToWorkspace copies the Linear provider config and credential (API
// key) from sourceWorkspaceID to targetWorkspaceID. Watchers are intentionally
// out of scope — only the connection settings and secret are duplicated.
func (s *Service) CopyConfigToWorkspace(ctx context.Context, sourceWorkspaceID, targetWorkspaceID string) (*LinearConfig, error) {
	// Authorize BOTH workspaces up front. The integration middleware only
	// authorizes the source (workspace_id query param); the target arrives in the
	// request body and is otherwise unchecked, so a caller could copy their config
	// and credential into another user's workspace by naming its ID here. Guard
	// before the target health-row write below, not just before the config write.
	sourceWorkspaceID, err := s.resolveWorkspaceID(ctx, sourceWorkspaceID)
	if err != nil {
		return nil, err
	}
	targetWorkspaceID, err = s.resolveWorkspaceID(ctx, targetWorkspaceID)
	if err != nil {
		return nil, err
	}
	if sourceWorkspaceID == targetWorkspaceID {
		return nil, ErrSameWorkspace
	}
	cfg, err := s.store.GetConfigForWorkspace(ctx, sourceWorkspaceID)
	if err != nil {
		return nil, fmt.Errorf("read source linear config: %w", err)
	}
	if cfg == nil {
		return nil, ErrNothingToCopy
	}
	secret, err := s.revealSecret(ctx, sourceWorkspaceID)
	if err != nil {
		return nil, fmt.Errorf("read source linear secret: %w", err)
	}
	// An empty Secret means "keep existing" in SetConfigForWorkspace, so copying
	// from a workspace without a stored API key would leave the target on its old
	// credential paired with the copied settings. Treat that as nothing to copy.
	if secret == "" {
		return nil, ErrNothingToCopy
	}
	req := &SetConfigRequest{
		AuthMethod:     cfg.AuthMethod,
		DefaultTeamKey: cfg.DefaultTeamKey,
		Secret:         secret,
	}
	// Mark the target unhealthy before the write so the UI doesn't briefly flash
	// a stale "connected" state (from a previously connected org) while the async
	// probe kicked off by SetConfigForWorkspace validates the copied credential.
	if err := s.store.UpdateAuthHealthForWorkspace(ctx, targetWorkspaceID, false, "", "", time.Now().UTC()); err != nil {
		return nil, fmt.Errorf("reset target linear health: %w", err)
	}
	cfgOut, err := s.SetConfigForWorkspace(ctx, targetWorkspaceID, req)
	if err != nil {
		// The write failed, so the target's config is unchanged but we already
		// flipped its health row. Re-probe asynchronously (best effort) so the row
		// reflects the target's real state again rather than a spurious
		// "unhealthy", without delaying the error response by the probe timeout.
		// Detach from the request context, which may already be cancelled.
		go s.RecordAuthHealthForWorkspace(context.Background(), targetWorkspaceID)
		return nil, err
	}
	return cfgOut, nil
}