fix: address golangci-lint warnings

- Remove unused readKeys parameter from Coordinate.dispatchTxn and
  ShardedCoordinator.dispatchSingleShardTxn (unparam)
- Extract validateReadKeysOnShard to reduce validateReadOnlyShards
  cyclomatic complexity below cyclop threshold
- Fix gci import ordering in sharded_coordinator_txn_test.go

Author: bootjp

kv/coordinator.go

@@ -75,7 +75,7 @@ func (c *Coordinate) Dispatch(ctx context.Context, reqs *OperationGroup[OP]) (*C
 	}
 
 	if reqs.IsTxn {
-		return c.dispatchTxn(reqs.Elems, reqs.StartTS, reqs.CommitTS, reqs.ReadKeys)
+		return c.dispatchTxn(reqs.Elems, reqs.StartTS, reqs.CommitTS)
 	}
 
 	return c.dispatchRaw(reqs.Elems)
@@ -122,7 +122,7 @@ func (c *Coordinate) nextStartTS() uint64 {
 	return c.clock.Next()
 }
 
-func (c *Coordinate) dispatchTxn(reqs []*Elem[OP], startTS uint64, commitTS uint64, readKeys [][]byte) (*CoordinateResponse, error) {
+func (c *Coordinate) dispatchTxn(reqs []*Elem[OP], startTS uint64, commitTS uint64) (*CoordinateResponse, error) {
 	primary := primaryKeyForElems(reqs)
 	if len(primary) == 0 {
 		return nil, errors.WithStack(ErrTxnPrimaryKeyRequired)

kv/coordinator_txn_test.go

@@ -36,7 +36,7 @@ func TestCoordinateDispatchTxn_RejectsNonMonotonicCommitTS(t *testing.T) {
 
 	_, err := c.dispatchTxn([]*Elem[OP]{
 		{Op: Put, Key: []byte("k"), Value: []byte("v")},
-	}, startTS, 0, nil)
+	}, startTS, 0)
 	require.ErrorIs(t, err, ErrTxnCommitTSRequired)
 	require.Equal(t, 0, tx.commits)
 }
@@ -52,7 +52,7 @@ func TestCoordinateDispatchTxn_RejectsMissingPrimaryKey(t *testing.T) {
 
 	_, err := c.dispatchTxn([]*Elem[OP]{
 		{Op: Put, Key: nil, Value: []byte("v")},
-	}, 1, 0, nil)
+	}, 1, 0)
 	require.ErrorIs(t, err, ErrTxnPrimaryKeyRequired)
 	require.Equal(t, 0, tx.commits)
 }
@@ -70,7 +70,7 @@ func TestCoordinateDispatchTxn_UsesOnePhaseRequest(t *testing.T) {
 	_, err := c.dispatchTxn([]*Elem[OP]{
 		{Op: Put, Key: []byte("b"), Value: []byte("v1")},
 		{Op: Del, Key: []byte("x")},
-	}, startTS, 0, nil)
+	}, startTS, 0)
 	require.NoError(t, err)
 	require.Equal(t, 1, tx.commits)
 	require.Len(t, tx.reqs, 1)
@@ -107,7 +107,7 @@ func TestCoordinateDispatchTxn_UsesProvidedCommitTS(t *testing.T) {
 	commitTS := uint64(25)
 	_, err := c.dispatchTxn([]*Elem[OP]{
 		{Op: Put, Key: []byte("k"), Value: []byte("v")},
-	}, startTS, commitTS, nil)
+	}, startTS, commitTS)
 	require.NoError(t, err)
 	require.Len(t, tx.reqs, 1)
 	require.Len(t, tx.reqs[0], 1)
@@ -117,24 +117,5 @@ func TestCoordinateDispatchTxn_UsesProvidedCommitTS(t *testing.T) {
 	require.Equal(t, commitTS, meta.CommitTS)
 }
 
-func TestCoordinateDispatchTxn_ReadKeysNotInOnePhaseTxnRequest(t *testing.T) {
-	t.Parallel()
-
-	tx := &stubTransactional{}
-	c := &Coordinate{
-		transactionManager: tx,
-		clock:              NewHLC(),
-	}
-
-	// Single-shard transactions validate read keys pre-Raft (in the adapter),
-	// so readKeys must NOT be included in the Raft log entry to avoid
-	// post-commit rejections that break realtime ordering.
-	readKeys := [][]byte{[]byte("rk1"), []byte("rk2")}
-	_, err := c.dispatchTxn([]*Elem[OP]{
-		{Op: Put, Key: []byte("k"), Value: []byte("v")},
-	}, 10, 0, readKeys)
-	require.NoError(t, err)
-	require.Len(t, tx.reqs, 1)
-	require.Len(t, tx.reqs[0], 1)
-	require.Nil(t, tx.reqs[0][0].ReadKeys)
-}
+// ReadKeys omission from single-shard Raft entries is tested in
+// TestShardedCoordinatorDispatchTxn_SingleShardOmitsReadKeysFromRaftEntry.

kv/sharded_coordinator.go

@@ -209,7 +209,7 @@ func (c *ShardedCoordinator) dispatchTxn(ctx context.Context, startTS uint64, co
 	}
 
 	if len(gids) == 1 {
-		return c.dispatchSingleShardTxn(startTS, commitTS, primaryKey, gids[0], elems, readKeys)
+		return c.dispatchSingleShardTxn(startTS, commitTS, primaryKey, gids[0], elems)
 	}
 
 	prepared, err := c.prewriteTxn(ctx, startTS, commitTS, primaryKey, grouped, gids, readKeys)
@@ -241,7 +241,7 @@ func (c *ShardedCoordinator) resolveTxnCommitTS(startTS, commitTS uint64) (uint6
 	return commitTS, nil
 }
 
-func (c *ShardedCoordinator) dispatchSingleShardTxn(startTS, commitTS uint64, primaryKey []byte, gid uint64, elems []*Elem[OP], readKeys [][]byte) (*CoordinateResponse, error) {
+func (c *ShardedCoordinator) dispatchSingleShardTxn(startTS, commitTS uint64, primaryKey []byte, gid uint64, elems []*Elem[OP]) (*CoordinateResponse, error) {
 	g, err := c.txnGroupForID(gid)
 	if err != nil {
 		return nil, err
@@ -642,25 +642,32 @@ func (c *ShardedCoordinator) validateReadOnlyShards(ctx context.Context, grouped
 		if _, isWrite := writeSet[gid]; isWrite {
 			continue
 		}
-		g, ok := c.groups[gid]
-		if !ok {
-			continue
+		if err := c.validateReadKeysOnShard(ctx, gid, keys, startTS); err != nil {
+			return err
 		}
-		// Linearizable read barrier: wait until the shard's FSM has applied
-		// all Raft-committed entries so LatestCommitTS reflects the latest
-		// committed state. Without this, a concurrent write that is committed
-		// in Raft but not yet applied locally would be invisible.
-		if _, err := linearizableReadEngineCtx(ctx, engineForGroup(g)); err != nil {
+	}
+	return nil
+}
+
+func (c *ShardedCoordinator) validateReadKeysOnShard(ctx context.Context, gid uint64, keys [][]byte, startTS uint64) error {
+	g, ok := c.groups[gid]
+	if !ok {
+		return nil
+	}
+	// Linearizable read barrier: wait until the shard's FSM has applied
+	// all Raft-committed entries so LatestCommitTS reflects the latest
+	// committed state. Without this, a concurrent write that is committed
+	// in Raft but not yet applied locally would be invisible.
+	if _, err := linearizableReadEngineCtx(ctx, engineForGroup(g)); err != nil {
+		return errors.WithStack(err)
+	}
+	for _, key := range keys {
+		ts, exists, err := g.Store.LatestCommitTS(ctx, key)
+		if err != nil {
 			return errors.WithStack(err)
 		}
-		for _, key := range keys {
-			ts, exists, err := g.Store.LatestCommitTS(ctx, key)
-			if err != nil {
-				return errors.WithStack(err)
-			}
-			if exists && ts > startTS {
-				return errors.WithStack(store.NewWriteConflictError(key))
-			}
+		if exists && ts > startTS {
+			return errors.WithStack(store.NewWriteConflictError(key))
 		}
 	}
 	return nil

kv/sharded_coordinator_txn_test.go

@@ -6,12 +6,13 @@ import (
 	"sync"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
+
 	"github.com/bootjp/elastickv/distribution"
 	"github.com/bootjp/elastickv/internal/raftengine"
 	pb "github.com/bootjp/elastickv/proto"
 	"github.com/bootjp/elastickv/store"
-	"github.com/stretchr/testify/require"
-	"google.golang.org/protobuf/proto"
 )
 
 type recordingTransactional struct {