refactor: use SDK subsystems types in FDv2 polling

Replace locally-defined FDv2 wire-format types with the equivalent types
from go-server-sdk/v7/subsystems: RawEvent, PollingPayload, PutObject,
ServerIntent, Selector, and the IntentTransferFull/IntentNone/FlagKind
constants. The three reason strings (up-to-date, cant-catchup,
payload-missing) have no SDK equivalents and remain as local constants.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hkotian

internal/dev_server/sdk/fdv2.go

@@ -6,56 +6,16 @@ import (
 	"strconv"
 	"strings"
 
+	"github.com/launchdarkly/go-server-sdk/v7/subsystems"
 	"github.com/launchdarkly/ldcli/internal/dev_server/model"
 )
 
 const (
-	fdv2EventServerIntent       = "server-intent"
-	fdv2EventPutObject          = "put-object"
-	fdv2EventPayloadTransferred = "payload-transferred"
-
-	fdv2IntentXferFull = "xfer-full"
-	fdv2IntentNone     = "none"
-
 	fdv2ReasonUpToDate       = "up-to-date"
 	fdv2ReasonCantCatchup    = "cant-catchup"
 	fdv2ReasonPayloadMissing = "payload-missing"
 )
 
-// fdv2RawEvent matches the wire format the SDK deserializes from the /sdk/poll response.
-// The SDK's RawEvent uses json:"event" (not json:"name") as of v7.13+.
-type fdv2RawEvent struct {
-	Event string          `json:"event"`
-	Data  json.RawMessage `json:"data"`
-}
-
-type fdv2Payload struct {
-	ID         string `json:"id"`
-	Target     int    `json:"target"`
-	IntentCode string `json:"intentCode"`
-	Reason     string `json:"reason"`
-}
-
-type fdv2ServerIntentData struct {
-	Payloads []fdv2Payload `json:"payloads"`
-}
-
-type fdv2PutObjectData struct {
-	Version int             `json:"version"`
-	Kind    string          `json:"kind"`
-	Key     string          `json:"key"`
-	Object  json.RawMessage `json:"object"`
-}
-
-type fdv2PayloadTransferredData struct {
-	State   string `json:"state"`
-	Version int    `json:"version"`
-}
-
-type fdv2PollResponse struct {
-	Events []fdv2RawEvent `json:"events"`
-}
-
 // parseBasisVersion extracts the payload version from a basis state string of the
 // form "(p:<payloadId>:<version>)". Returns 0 if the string is absent or unparseable.
 func parseBasisVersion(basis string) int {
@@ -80,85 +40,86 @@ func parseBasisVersion(basis string) int {
 // currentVersion is the project's current PayloadVersion.
 // flags is the current flag state with overrides applied.
 // basisVersion is parsed from the SDK's ?basis query param (0 = no basis provided).
-func buildPollResponse(payloadID string, currentVersion int, flags model.FlagsState, basisVersion int) (fdv2PollResponse, error) {
+//
+// Delta transfers are not supported: stale clients always receive a full payload.
+// Tracking the change history required for deltas is overkill for a local dev server.
+func buildPollResponse(payloadID string, currentVersion int, flags model.FlagsState, basisVersion int) (subsystems.PollingPayload, error) {
 	switch {
 	case basisVersion == 0:
 		return buildFullTransferResponse(payloadID, currentVersion, flags, fdv2ReasonPayloadMissing)
 	case basisVersion >= currentVersion:
-		event, err := makeServerIntentEvent(payloadID, currentVersion, fdv2IntentNone, fdv2ReasonUpToDate)
+		event, err := makeServerIntentEvent(payloadID, currentVersion, subsystems.IntentNone, fdv2ReasonUpToDate)
 		if err != nil {
-			return fdv2PollResponse{}, err
+			return subsystems.PollingPayload{}, err
 		}
-		return fdv2PollResponse{Events: []fdv2RawEvent{event}}, nil
+		return subsystems.PollingPayload{Events: []subsystems.RawEvent{event}}, nil
 	default:
 		// Stale: we don't store history so we can't compute a delta — send the full payload.
 		return buildFullTransferResponse(payloadID, currentVersion, flags, fdv2ReasonCantCatchup)
 	}
 }
 
-func buildFullTransferResponse(payloadID string, version int, flags model.FlagsState, reason string) (fdv2PollResponse, error) {
-	intentEvent, err := makeServerIntentEvent(payloadID, version, fdv2IntentXferFull, reason)
+func buildFullTransferResponse(payloadID string, version int, flags model.FlagsState, reason string) (subsystems.PollingPayload, error) {
+	intentEvent, err := makeServerIntentEvent(payloadID, version, subsystems.IntentTransferFull, reason)
 	if err != nil {
-		return fdv2PollResponse{}, err
+		return subsystems.PollingPayload{}, err
 	}
-	events := []fdv2RawEvent{intentEvent}
+	events := []subsystems.RawEvent{intentEvent}
 
 	for key, flagState := range flags {
 		event, err := makePutObjectEvent(version, key, flagState)
 		if err != nil {
-			return fdv2PollResponse{}, err
+			return subsystems.PollingPayload{}, err
 		}
 		events = append(events, event)
 	}
 
 	transferredEvent, err := makePayloadTransferredEvent(payloadID, version)
 	if err != nil {
-		return fdv2PollResponse{}, err
+		return subsystems.PollingPayload{}, err
 	}
 	events = append(events, transferredEvent)
 
-	return fdv2PollResponse{Events: events}, nil
+	return subsystems.PollingPayload{Events: events}, nil
 }
 
-func makeServerIntentEvent(payloadID string, target int, intentCode, reason string) (fdv2RawEvent, error) {
-	data, err := json.Marshal(fdv2ServerIntentData{
-		Payloads: []fdv2Payload{{
-			ID:         payloadID,
-			Target:     target,
-			IntentCode: intentCode,
-			Reason:     reason,
-		}},
+func makeServerIntentEvent(payloadID string, target int, intentCode subsystems.IntentCode, reason string) (subsystems.RawEvent, error) {
+	data, err := json.Marshal(subsystems.ServerIntent{
+		Payload: subsystems.Payload{
+			ID:     payloadID,
+			Target: target,
+			Code:   intentCode,
+			Reason: reason,
+		},
 	})
 	if err != nil {
-		return fdv2RawEvent{}, err
+		return subsystems.RawEvent{}, err
 	}
-	return fdv2RawEvent{Event: fdv2EventServerIntent, Data: data}, nil
+	return subsystems.RawEvent{Name: subsystems.EventServerIntent, Data: data}, nil
 }
 
-func makePutObjectEvent(version int, key string, flagState model.FlagState) (fdv2RawEvent, error) {
+func makePutObjectEvent(version int, key string, flagState model.FlagState) (subsystems.RawEvent, error) {
 	object, err := json.Marshal(serverFlagFromFlagState(key, flagState))
 	if err != nil {
-		return fdv2RawEvent{}, err
+		return subsystems.RawEvent{}, err
 	}
-	data, err := json.Marshal(fdv2PutObjectData{
+	data, err := json.Marshal(subsystems.PutObject{
 		Version: version,
-		Kind:    "flag",
+		Kind:    subsystems.FlagKind,
 		Key:     key,
 		Object:  object,
 	})
 	if err != nil {
-		return fdv2RawEvent{}, err
+		return subsystems.RawEvent{}, err
 	}
-	return fdv2RawEvent{Event: fdv2EventPutObject, Data: data}, nil
+	return subsystems.RawEvent{Name: subsystems.EventPutObject, Data: data}, nil
 }
 
-func makePayloadTransferredEvent(payloadID string, version int) (fdv2RawEvent, error) {
-	data, err := json.Marshal(fdv2PayloadTransferredData{
-		State:   fmt.Sprintf("(p:%s:%d)", payloadID, version),
-		Version: version,
-	})
+func makePayloadTransferredEvent(payloadID string, version int) (subsystems.RawEvent, error) {
+	selector := subsystems.NewSelector(fmt.Sprintf("(p:%s:%d)", payloadID, version), version)
+	data, err := json.Marshal(selector)
 	if err != nil {
-		return fdv2RawEvent{}, err
+		return subsystems.RawEvent{}, err
 	}
-	return fdv2RawEvent{Event: fdv2EventPayloadTransferred, Data: data}, nil
+	return subsystems.RawEvent{Name: subsystems.EventPayloadTransferred, Data: data}, nil
 }

internal/dev_server/sdk/fdv2_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/gorilla/mux"
 	"github.com/launchdarkly/go-sdk-common/v3/ldcontext"
 	"github.com/launchdarkly/go-sdk-common/v3/ldvalue"
+	"github.com/launchdarkly/go-server-sdk/v7/subsystems"
 	"github.com/launchdarkly/ldcli/internal/dev_server/model"
 	"github.com/launchdarkly/ldcli/internal/dev_server/model/mocks"
 	"github.com/stretchr/testify/assert"
@@ -53,7 +54,7 @@ func TestBuildPollResponse(t *testing.T) {
 
 		require.GreaterOrEqual(t, len(resp.Events), 3) // server-intent + put-objects + payload-transferred
 
-		assertServerIntentEvent(t, resp.Events[0], payloadID, currentVersion, fdv2IntentXferFull, fdv2ReasonPayloadMissing)
+		assertServerIntentEvent(t, resp.Events[0], payloadID, currentVersion, subsystems.IntentTransferFull, fdv2ReasonPayloadMissing)
 		assertPayloadTransferredEvent(t, resp.Events[len(resp.Events)-1], payloadID, currentVersion)
 	})
 
@@ -62,23 +63,23 @@ func TestBuildPollResponse(t *testing.T) {
 		require.NoError(t, err)
 
 		require.Len(t, resp.Events, 1)
-		assertServerIntentEvent(t, resp.Events[0], payloadID, currentVersion, fdv2IntentNone, fdv2ReasonUpToDate)
+		assertServerIntentEvent(t, resp.Events[0], payloadID, currentVersion, subsystems.IntentNone, fdv2ReasonUpToDate)
 	})
 
 	t.Run("basis ahead of current version sends none with up-to-date", func(t *testing.T) {
 		resp, err := buildPollResponse(payloadID, currentVersion, flags, currentVersion+10)
 		require.NoError(t, err)
 
 		require.Len(t, resp.Events, 1)
-		assertServerIntentEvent(t, resp.Events[0], payloadID, currentVersion, fdv2IntentNone, fdv2ReasonUpToDate)
+		assertServerIntentEvent(t, resp.Events[0], payloadID, currentVersion, subsystems.IntentNone, fdv2ReasonUpToDate)
 	})
 
 	t.Run("stale basis sends xfer-full with cant-catchup", func(t *testing.T) {
 		resp, err := buildPollResponse(payloadID, currentVersion, flags, currentVersion-1)
 		require.NoError(t, err)
 
 		require.GreaterOrEqual(t, len(resp.Events), 3)
-		assertServerIntentEvent(t, resp.Events[0], payloadID, currentVersion, fdv2IntentXferFull, fdv2ReasonCantCatchup)
+		assertServerIntentEvent(t, resp.Events[0], payloadID, currentVersion, subsystems.IntentTransferFull, fdv2ReasonCantCatchup)
 		assertPayloadTransferredEvent(t, resp.Events[len(resp.Events)-1], payloadID, currentVersion)
 	})
 
@@ -94,12 +95,12 @@ func TestBuildPollResponse(t *testing.T) {
 		assert.Len(t, resp.Events, 4)
 		putKeys := make(map[string]bool)
 		for _, event := range resp.Events {
-			if event.Event == fdv2EventPutObject {
-				var put fdv2PutObjectData
+			if event.Name == subsystems.EventPutObject {
+				var put subsystems.PutObject
 				require.NoError(t, json.Unmarshal(event.Data, &put))
 				putKeys[put.Key] = true
 				assert.Equal(t, currentVersion, put.Version)
-				assert.Equal(t, "flag", put.Kind)
+				assert.Equal(t, subsystems.FlagKind, put.Kind)
 			}
 		}
 		assert.True(t, putKeys["flag-a"])
@@ -141,10 +142,10 @@ func TestPollV2Handler(t *testing.T) {
 		require.Equal(t, http.StatusOK, rec.Code)
 		assert.Equal(t, "application/json", rec.Header().Get("Content-Type"))
 
-		var resp fdv2PollResponse
+		var resp subsystems.PollingPayload
 		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
 		require.GreaterOrEqual(t, len(resp.Events), 3)
-		assertServerIntentEvent(t, resp.Events[0], exampleProjectKey, 3, fdv2IntentXferFull, fdv2ReasonPayloadMissing)
+		assertServerIntentEvent(t, resp.Events[0], exampleProjectKey, 3, subsystems.IntentTransferFull, fdv2ReasonPayloadMissing)
 		assertPayloadTransferredEvent(t, resp.Events[len(resp.Events)-1], exampleProjectKey, 3)
 	})
 
@@ -160,10 +161,10 @@ func TestPollV2Handler(t *testing.T) {
 
 		require.Equal(t, http.StatusOK, rec.Code)
 
-		var resp fdv2PollResponse
+		var resp subsystems.PollingPayload
 		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
 		require.Len(t, resp.Events, 1)
-		assertServerIntentEvent(t, resp.Events[0], exampleProjectKey, 3, fdv2IntentNone, fdv2ReasonUpToDate)
+		assertServerIntentEvent(t, resp.Events[0], exampleProjectKey, 3, subsystems.IntentNone, fdv2ReasonUpToDate)
 	})
 
 	t.Run("stale basis returns full payload with cant-catchup", func(t *testing.T) {
@@ -178,10 +179,10 @@ func TestPollV2Handler(t *testing.T) {
 
 		require.Equal(t, http.StatusOK, rec.Code)
 
-		var resp fdv2PollResponse
+		var resp subsystems.PollingPayload
 		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
 		require.GreaterOrEqual(t, len(resp.Events), 3)
-		assertServerIntentEvent(t, resp.Events[0], exampleProjectKey, 3, fdv2IntentXferFull, fdv2ReasonCantCatchup)
+		assertServerIntentEvent(t, resp.Events[0], exampleProjectKey, 3, subsystems.IntentTransferFull, fdv2ReasonCantCatchup)
 		assertPayloadTransferredEvent(t, resp.Events[len(resp.Events)-1], exampleProjectKey, 3)
 	})
 
@@ -198,24 +199,23 @@ func TestPollV2Handler(t *testing.T) {
 }
 
 // assertServerIntentEvent unmarshals a server-intent event and checks its fields.
-func assertServerIntentEvent(t *testing.T, event fdv2RawEvent, payloadID string, target int, intentCode, reason string) {
+func assertServerIntentEvent(t *testing.T, event subsystems.RawEvent, payloadID string, target int, intentCode subsystems.IntentCode, reason string) {
 	t.Helper()
-	assert.Equal(t, fdv2EventServerIntent, event.Event)
-	var data fdv2ServerIntentData
+	assert.Equal(t, subsystems.EventServerIntent, event.Name)
+	var data subsystems.ServerIntent
 	require.NoError(t, json.Unmarshal(event.Data, &data))
-	require.Len(t, data.Payloads, 1)
-	assert.Equal(t, payloadID, data.Payloads[0].ID)
-	assert.Equal(t, target, data.Payloads[0].Target)
-	assert.Equal(t, intentCode, data.Payloads[0].IntentCode)
-	assert.Equal(t, reason, data.Payloads[0].Reason)
+	assert.Equal(t, payloadID, data.Payload.ID)
+	assert.Equal(t, target, data.Payload.Target)
+	assert.Equal(t, intentCode, data.Payload.Code)
+	assert.Equal(t, reason, data.Payload.Reason)
 }
 
 // assertPayloadTransferredEvent unmarshals a payload-transferred event and checks its fields.
-func assertPayloadTransferredEvent(t *testing.T, event fdv2RawEvent, payloadID string, version int) {
+func assertPayloadTransferredEvent(t *testing.T, event subsystems.RawEvent, payloadID string, version int) {
 	t.Helper()
-	assert.Equal(t, fdv2EventPayloadTransferred, event.Event)
-	var data fdv2PayloadTransferredData
+	assert.Equal(t, subsystems.EventPayloadTransferred, event.Name)
+	var data subsystems.Selector
 	require.NoError(t, json.Unmarshal(event.Data, &data))
-	assert.Equal(t, version, data.Version)
-	assert.Equal(t, fmt.Sprintf("(p:%s:%d)", payloadID, version), data.State)
+	assert.Equal(t, version, data.Version())
+	assert.Equal(t, fmt.Sprintf("(p:%s:%d)", payloadID, version), data.State())
 }