feat: enhance resource synchronization with variable support

- Introduced a new resourceInput struct to handle resource variables.
- Updated parseResources and validateResources functions to work with resourceInput.
- Implemented syncResourceVariables function to manage variable updates with retry logic.
- Adjusted NewSyncPipeCmd to accommodate new resource structure and variable handling.

Author: jsbroks

cmd/ctrlc/root/sync/netbox/devices/devices.go

@@ -126,9 +126,9 @@ func mapDevice(device netbox.DeviceWithConfigContext) api.ResourceProviderResour
 		"name":        device.GetName(),
 		"device_type": device.DeviceType.GetDisplay(),
 		"role":        device.Role.GetName(),
-		"site":        map[string]any{
+		"site": map[string]any{
 			"id":   site.Id,
-			"url": site.Url,
+			"url":  site.Url,
 			"slug": site.Slug,
 			"name": site.Name,
 		},

cmd/ctrlc/root/sync/pipe/pipe.go

@@ -7,8 +7,10 @@ import (
 	"io"
 	"os"
 	"strings"
+	"time"
 
 	"github.com/MakeNowJust/heredoc/v2"
+	"github.com/avast/retry-go"
 	"github.com/charmbracelet/log"
 	"github.com/ctrlplanedev/cli/internal/api"
 	"github.com/ctrlplanedev/cli/internal/cliutil"
@@ -35,6 +37,10 @@ func NewSyncPipeCmd() *cobra.Command {
 			$ echo '{"name":"web-1","identifier":"web-1-prod","version":"custom/v1","kind":"Server"}' \
 			    | ctrlc sync pipe --provider "my-servers"
 
+			# Resource with variables
+			$ echo '[{"name":"web-1","identifier":"web-1-prod","version":"custom/v1","kind":"Server","variables":{"env":"prod","tier":"frontend"}}]' \
+			    | ctrlc sync pipe --provider "my-servers"
+
 			# From curl with jq transformation
 			$ curl -s https://cmdb.internal/api/servers \
 			    | jq '[.[] | {name, identifier: .id, version: "cmdb/v1", kind: "Server", config: ., metadata: {}}]' \
@@ -60,16 +66,17 @@ func NewSyncPipeCmd() *cobra.Command {
 			}
 
 			// Parse JSON -- try array first, then single object
-			resources, err := parseResources(data)
+			resourceInputs, err := parseResources(data)
 			if err != nil {
 				return err
 			}
 
 			// Validate required fields
-			if err := validateResources(resources); err != nil {
+			if err := validateResources(resourceInputs); err != nil {
 				return err
 			}
 
+			resources := toAPIResources(resourceInputs)
 			log.Info("Syncing resources from stdin", "count", len(resources), "provider", providerName)
 
 			// Create API client
@@ -94,6 +101,11 @@ func NewSyncPipeCmd() *cobra.Command {
 				return fmt.Errorf("failed to upsert resources: %w", err)
 			}
 
+			workspaceID := ctrlplaneClient.GetWorkspaceID(ctx, workspace).String()
+			if err := syncResourceVariables(ctx, ctrlplaneClient, workspaceID, resourceInputs); err != nil {
+				return err
+			}
+
 			log.Info("Response from upserting resources", "status", upsertResp.Status)
 
 			return cliutil.HandleResponseOutput(cmd, upsertResp)
@@ -106,20 +118,79 @@ func NewSyncPipeCmd() *cobra.Command {
 	return cmd
 }
 
+type resourceInput struct {
+	Name       string            `json:"name"`
+	Identifier string            `json:"identifier"`
+	Version    string            `json:"version"`
+	Kind       string            `json:"kind"`
+	Config     map[string]any    `json:"config"`
+	Metadata   map[string]string `json:"metadata"`
+	Variables  map[string]any    `json:"-"`
+
+	hasVariables bool `json:"-"`
+}
+
+func (r *resourceInput) UnmarshalJSON(data []byte) error {
+	type resourceInputAlias struct {
+		Name       string                 `json:"name"`
+		Identifier string                 `json:"identifier"`
+		Version    string                 `json:"version"`
+		Kind       string                 `json:"kind"`
+		Config     map[string]interface{} `json:"config"`
+		Metadata   map[string]string      `json:"metadata"`
+	}
+
+	var alias resourceInputAlias
+	if err := json.Unmarshal(data, &alias); err != nil {
+		return err
+	}
+
+	var raw map[string]json.RawMessage
+	if err := json.Unmarshal(data, &raw); err != nil {
+		return err
+	}
+
+	r.Name = alias.Name
+	r.Identifier = alias.Identifier
+	r.Version = alias.Version
+	r.Kind = alias.Kind
+	r.Config = alias.Config
+	r.Metadata = alias.Metadata
+
+	varRaw, ok := raw["variables"]
+	if !ok {
+		r.hasVariables = false
+		return nil
+	}
+
+	r.hasVariables = true
+	if string(varRaw) == "null" {
+		r.Variables = map[string]any{}
+		return nil
+	}
+
+	var vars map[string]any
+	if err := json.Unmarshal(varRaw, &vars); err != nil {
+		return fmt.Errorf("invalid variables field: must be a JSON object")
+	}
+	r.Variables = vars
+	return nil
+}
+
 // parseResources attempts to parse the raw JSON data as either an array of
 // resources or a single resource object. A single object is normalized to a
 // one-element array.
-func parseResources(data []byte) ([]api.ResourceProviderResource, error) {
+func parseResources(data []byte) ([]resourceInput, error) {
 	// Try array first
-	var resources []api.ResourceProviderResource
+	var resources []resourceInput
 	if err := json.Unmarshal(data, &resources); err == nil {
 		return resources, nil
 	}
 
 	// Try single object
-	var single api.ResourceProviderResource
+	var single resourceInput
 	if err := json.Unmarshal(data, &single); err == nil {
-		return []api.ResourceProviderResource{single}, nil
+		return []resourceInput{single}, nil
 	}
 
 	// Show a snippet of the input for debugging
@@ -130,9 +201,24 @@ func parseResources(data []byte) ([]api.ResourceProviderResource, error) {
 	return nil, fmt.Errorf("invalid JSON input: %s", snippet)
 }
 
+func toAPIResources(resources []resourceInput) []api.ResourceProviderResource {
+	out := make([]api.ResourceProviderResource, 0, len(resources))
+	for _, r := range resources {
+		out = append(out, api.ResourceProviderResource{
+			Name:       r.Name,
+			Identifier: r.Identifier,
+			Version:    r.Version,
+			Kind:       r.Kind,
+			Config:     r.Config,
+			Metadata:   r.Metadata,
+		})
+	}
+	return out
+}
+
 // validateResources checks that each resource has the required fields:
 // Name, Identifier, Version, Kind.
-func validateResources(resources []api.ResourceProviderResource) error {
+func validateResources(resources []resourceInput) error {
 	var errs []string
 	for i, r := range resources {
 		var missing []string
@@ -157,3 +243,56 @@ func validateResources(resources []api.ResourceProviderResource) error {
 	}
 	return nil
 }
+
+func syncResourceVariables(
+	ctx context.Context,
+	client *api.ClientWithResponses,
+	workspaceID string,
+	resources []resourceInput,
+) error {
+	for _, resource := range resources {
+		if !resource.hasVariables {
+			continue
+		}
+
+		vars := resource.Variables
+		if vars == nil {
+			vars = map[string]any{}
+		}
+
+		err := retry.Do(
+			func() error {
+				varsResp, err := client.RequestResourceVariablesUpdateWithResponse(
+					ctx,
+					workspaceID,
+					resource.Identifier,
+					api.RequestResourceVariablesUpdateJSONRequestBody(vars),
+				)
+				if err != nil {
+					return retry.Unrecoverable(fmt.Errorf("failed to update resource variables for '%s': %w", resource.Identifier, err))
+				}
+				if varsResp == nil {
+					return retry.Unrecoverable(fmt.Errorf("failed to update resource variables for '%s': empty response", resource.Identifier))
+				}
+				if varsResp.StatusCode() == 404 {
+					return fmt.Errorf("resource '%s' not found yet, retrying", resource.Identifier)
+				}
+				if varsResp.StatusCode() != 204 {
+					return retry.Unrecoverable(
+						fmt.Errorf("failed to update resource variables for '%s': %s", resource.Identifier, string(varsResp.Body)),
+					)
+				}
+				return nil
+			},
+			retry.Attempts(10),
+			retry.Delay(100*time.Millisecond),
+			retry.MaxDelay(15*time.Second),
+			retry.DelayType(retry.BackOffDelay),
+		)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

cmd/ctrlc/root/sync/pipe/pipe_test.go

@@ -0,0 +1,72 @@
+package pipe
+
+import "testing"
+
+func TestParseResources_ArrayWithVariables(t *testing.T) {
+	input := []byte(`[
+		{"name":"web-1","identifier":"web-1-prod","version":"custom/v1","kind":"Server","variables":{"env":"prod"}},
+		{"name":"web-2","identifier":"web-2-prod","version":"custom/v1","kind":"Server"}
+	]`)
+
+	resources, err := parseResources(input)
+	if err != nil {
+		t.Fatalf("parseResources returned error: %v", err)
+	}
+	if len(resources) != 2 {
+		t.Fatalf("expected 2 resources, got %d", len(resources))
+	}
+
+	if !resources[0].hasVariables {
+		t.Fatalf("expected resource[0] to have variables")
+	}
+	if resources[0].Variables["env"] != "prod" {
+		t.Fatalf("expected resource[0].variables.env to be prod, got %#v", resources[0].Variables["env"])
+	}
+
+	if resources[1].hasVariables {
+		t.Fatalf("expected resource[1] to not have variables")
+	}
+}
+
+func TestParseResources_SingleObject(t *testing.T) {
+	input := []byte(`{"name":"web-1","identifier":"web-1-prod","version":"custom/v1","kind":"Server","variables":null}`)
+
+	resources, err := parseResources(input)
+	if err != nil {
+		t.Fatalf("parseResources returned error: %v", err)
+	}
+	if len(resources) != 1 {
+		t.Fatalf("expected 1 resource, got %d", len(resources))
+	}
+	if !resources[0].hasVariables {
+		t.Fatalf("expected resource to have variables present")
+	}
+	if resources[0].Variables == nil {
+		t.Fatalf("expected null variables to normalize to empty map")
+	}
+}
+
+func TestParseResources_InvalidVariablesType(t *testing.T) {
+	input := []byte(`{"name":"web-1","identifier":"web-1-prod","version":"custom/v1","kind":"Server","variables":"bad"}`)
+
+	_, err := parseResources(input)
+	if err == nil {
+		t.Fatalf("expected parseResources to fail for invalid variables type")
+	}
+}
+
+func TestValidateResources_UnchangedRequiredFields(t *testing.T) {
+	resources := []resourceInput{
+		{
+			Name:       "",
+			Identifier: "id-1",
+			Version:    "",
+			Kind:       "Server",
+		},
+	}
+
+	err := validateResources(resources)
+	if err == nil {
+		t.Fatalf("expected validation to fail")
+	}
+}