fix(sqs): buildSQSPartitionResolver returns interface to avoid typed-nil

Round 1 Claude review on PR #715 caught a typed-nil interface bug:
buildSQSPartitionResolver had return type *adapter.SQSPartitionResolver,
so on a non-partitioned cluster it returned a typed-nil pointer.
When that pointer was passed into kv.ShardRouter.WithPartitionResolver
(parameter type kv.PartitionResolver), Go wrapped it into a NON-NIL
interface — the resolver-first short-circuit
`s.partitionResolver != nil` would always pass on every request,
defeating the "non-partitioned cluster keeps engine-only hot path"
contract from the PR description.

The (*SQSPartitionResolver).ResolveGroup nil-receiver guard kept this
functionally safe (correct routing) but not free (extra map lookup
per request).

Fix

- Return type changed from *adapter.SQSPartitionResolver to
  kv.PartitionResolver. Untyped `nil` returns now propagate as a
  true nil interface, the short-circuit fires correctly, and the
  hot path stays engine-only.
- Defensive nil guard after NewSQSPartitionResolver in case
  canonicalisation collapses every entry — the typed pointer from
  the constructor would otherwise wrap to a non-nil interface
  even when its underlying pointer is nil.
- New main_sqs_resolver_test.go regression test:
  TestBuildSQSPartitionResolver_NilOnEmpty uses requireNilInterface
  to force the kv.PartitionResolver conversion at the call boundary
  (a plain require.Nil on the concrete pointer would pass even with
  the bug present, since the pointer itself IS nil — only the
  interface wrap exposes the failure mode).
- TestBuildSQSPartitionResolver_NonEmptyReturnsResolver pins the
  happy path so a future "always return nil" regression is caught.

Author: bootjp

main.go

@@ -486,13 +486,24 @@ func buildLeaderSQS(groups []groupSpec, sqsAddr string, raftSqsMap string) (map[
 // is a documented no-op, so the request hot path keeps the existing
 // engine-only dispatch.
 //
+// Return type is the kv.PartitionResolver interface, NOT the
+// concrete *adapter.SQSPartitionResolver, because Go wraps a typed
+// nil pointer into a NON-NIL interface value when the function
+// signature is the concrete type. With a concrete return type, a
+// non-partitioned cluster would carry a non-nil interface whose
+// underlying pointer is nil, the resolver-first short-circuit
+// `s.partitionResolver != nil` would always pass, and every request
+// would pay an extra ResolveGroup call (which the nil-receiver
+// guard makes safe but not free). The interface return type makes
+// the untyped `nil` propagate as a true nil interface.
+//
 // The group-reference parsing here cannot fail in practice because
 // parseSQSFifoGroupList already canonicalized each entry as a
 // uint64 string at flag-parse time; the conversion is repeated
 // defensively so a future caller that bypasses parseSQSFifoGroupList
 // (e.g. a test seeding the map programmatically) gets a clear panic
 // instead of a silent route-to-group-zero.
-func buildSQSPartitionResolver(partitionMap map[string]sqsFifoQueueRouting) *adapter.SQSPartitionResolver {
+func buildSQSPartitionResolver(partitionMap map[string]sqsFifoQueueRouting) kv.PartitionResolver {
 	if len(partitionMap) == 0 {
 		return nil
 	}
@@ -514,7 +525,16 @@ func buildSQSPartitionResolver(partitionMap map[string]sqsFifoQueueRouting) *ada
 		}
 		flat[queue] = ids
 	}
-	return adapter.NewSQSPartitionResolver(flat)
+	r := adapter.NewSQSPartitionResolver(flat)
+	if r == nil {
+		// Defensive: NewSQSPartitionResolver returns nil on an
+		// empty input. The len-check above already short-circuits
+		// for empty partitionMap, so reaching this branch means
+		// the canonicalisation collapsed every entry — surface as
+		// a true nil interface, not a typed-nil pointer wrapper.
+		return nil
+	}
+	return r
 }
 
 // buildSQSFifoPartitionMap parses and validates the

main_sqs_resolver_test.go

@@ -0,0 +1,71 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/bootjp/elastickv/kv"
+	"github.com/stretchr/testify/require"
+)
+
+// TestBuildSQSPartitionResolver_NilOnEmpty pins the typed-nil
+// interface invariant flagged by the Phase 3.D PR 4-B-2 round-1
+// review: buildSQSPartitionResolver MUST return a true-nil
+// kv.PartitionResolver interface (not a typed-nil pointer wrapped
+// in a non-nil interface) when the partition map is empty or nil.
+//
+// If the function's return type were the concrete
+// *adapter.SQSPartitionResolver and the body returned a nil
+// pointer, Go would wrap that pointer into a NON-NIL interface
+// when assigned to kv.ShardRouter.partitionResolver. The router's
+// resolver-first short-circuit `s.partitionResolver != nil` would
+// always pass on a non-partitioned cluster, and every request
+// would pay an extra ResolveGroup call (which the nil-receiver
+// guard inside (*SQSPartitionResolver).ResolveGroup makes safe
+// but not free).
+//
+// requireNilInterface forces the interface conversion at the call
+// boundary, which is what makes this regression observable. A
+// plain require.Nil(t, r) would pass even with a typed-nil because
+// at that point r still has the concrete pointer type.
+func TestBuildSQSPartitionResolver_NilOnEmpty(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		name string
+		in   map[string]sqsFifoQueueRouting
+	}{
+		{"nil map", nil},
+		{"empty map", map[string]sqsFifoQueueRouting{}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+			requireNilInterface(t, buildSQSPartitionResolver(tc.in),
+				"buildSQSPartitionResolver("+tc.name+
+					") must produce a true nil interface, "+
+					"not a typed-nil pointer wrapper")
+		})
+	}
+}
+
+// TestBuildSQSPartitionResolver_NonEmptyReturnsResolver pins the
+// happy path: a non-empty partition map yields a non-nil resolver
+// that dispatches partition keys correctly.
+func TestBuildSQSPartitionResolver_NonEmptyReturnsResolver(t *testing.T) {
+	t.Parallel()
+	in := map[string]sqsFifoQueueRouting{
+		"orders.fifo": {partitionCount: 2, groups: []string{"10", "11"}},
+	}
+	r := buildSQSPartitionResolver(in)
+	require.NotNil(t, r,
+		"non-empty partition map must produce a non-nil resolver")
+}
+
+// requireNilInterface accepts a kv.PartitionResolver and asserts
+// the interface value (NOT just the underlying pointer) is nil.
+// The function-parameter conversion forces a typed-nil pointer to
+// be wrapped into a non-nil interface, which is exactly the
+// failure mode the regression test guards against.
+func requireNilInterface(t *testing.T, r kv.PartitionResolver, msg string) {
+	t.Helper()
+	require.Nil(t, r, msg)
+}