@stackonward/cli 1.4.0 → 1.5.1

package/dist/resources/templates/go-backend/internal/core/commandreplay/persistence_test.go

@@ -22,17 +22,21 @@ func TestCommandReplayRepositoryCreateAndFindByScope(t *testing.T) {
 	repo := NewCommandReplayRepository(db)
 	ctx := context.Background()
 
-	record := newPersistenceTestCommandReplayRecord("test.command.checkout", "quote:create", "idem-1", time.Now().Add(time.Hour))
+	record := newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_123", "quote:create", "idem-1", time.Now().Add(time.Hour))
 	require.NoError(t, repo.Create(ctx, record))
 
-	found, err := repo.FindByScope(ctx, " test.command.checkout ", " quote:create ", " idem-1 ")
+	found, err := repo.FindByScope(ctx, " test.command.checkout ", " identity ", " user_123 ", " quote:create ", " idem-1 ")
 	require.NoError(t, err)
 	require.NotNil(t, found)
 	require.Equal(t, "test.command.checkout", found.Namespace)
 	require.Equal(t, "quote:create", found.CommandScope)
 	require.Equal(t, "idem-1", found.IdempotencyKey)
 
-	missing, err := repo.FindByScope(ctx, "test.command.checkout", "quote:create", "idem-missing")
+	wrongPrincipal, err := repo.FindByScope(ctx, "test.command.checkout", "identity", "user_456", "quote:create", "idem-1")
+	require.NoError(t, err)
+	require.Nil(t, wrongPrincipal)
+
+	missing, err := repo.FindByScope(ctx, "test.command.checkout", "identity", "user_123", "quote:create", "idem-missing")
 	require.NoError(t, err)
 	require.Nil(t, missing)
 }
@@ -43,41 +47,64 @@ func TestCommandReplayRepositoryDuplicateCreateReturnsSentinel(t *testing.T) {
 	ctx := context.Background()
 	expiresAt := time.Now().Add(time.Hour)
 
-	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "quote:create", "idem-1", expiresAt)))
-	err := repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "quote:create", "idem-1", expiresAt))
+	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_123", "quote:create", "idem-1", expiresAt)))
+	err := repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_123", "quote:create", "idem-1", expiresAt))
 	require.Error(t, err)
 	require.True(t, errors.Is(err, ErrCommandReplayRecordExists))
 
-	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "quote:create", "idem-2", expiresAt)))
-	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "quote:update", "idem-1", expiresAt)))
-	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.fulfillment", "quote:create", "idem-1", expiresAt)))
-	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("other.command.checkout", "quote:create", "idem-1", expiresAt)))
+	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_456", "quote:create", "idem-1", expiresAt)))
+	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "service", "worker_123", "quote:create", "idem-1", expiresAt)))
+	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_123", "quote:create", "idem-2", expiresAt)))
+	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_123", "quote:update", "idem-1", expiresAt)))
+	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("test.command.fulfillment", "identity", "user_123", "quote:create", "idem-1", expiresAt)))
+	require.NoError(t, repo.Create(ctx, newPersistenceTestCommandReplayRecord("other.command.checkout", "identity", "user_123", "quote:create", "idem-1", expiresAt)))
 	var total int64
 	require.NoError(t, db.Model(&CommandReplayRecord{}).Count(&total).Error)
-	require.Equal(t, int64(5), total)
+	require.Equal(t, int64(7), total)
 }
 
 func TestCommandReplayRepositoryTryAcquireScopeLockRejectsSQLite(t *testing.T) {
 	db := newCommandReplayTestDB(t)
 	repo := NewCommandReplayRepository(db)
 
-	acquired, err := repo.TryAcquireScopeLock(context.Background(), "test.command.checkout", "quote:create", "idem-1")
+	acquired, err := repo.TryAcquireScopeLock(context.Background(), "test.command.checkout", "identity", "user_123", "quote:create", "idem-1")
 	require.Error(t, err)
 	require.False(t, acquired)
 }
 
+func TestCommandReplayScopeKeyPreservesFiveFieldBoundaries(t *testing.T) {
+	base := commandReplayScopeKey(" test.command.checkout ", " identity ", " user_123 ", " quote:create ", " idem-1 ")
+	require.Equal(t, commandReplayScopeKey("test.command.checkout", "identity", "user_123", "quote:create", "idem-1"), base)
+
+	variants := []string{
+		commandReplayScopeKey("other.command.checkout", "identity", "user_123", "quote:create", "idem-1"),
+		commandReplayScopeKey("test.command.checkout", "service", "user_123", "quote:create", "idem-1"),
+		commandReplayScopeKey("test.command.checkout", "identity", "user_456", "quote:create", "idem-1"),
+		commandReplayScopeKey("test.command.checkout", "identity", "user_123", "quote:update", "idem-1"),
+		commandReplayScopeKey("test.command.checkout", "identity", "user_123", "quote:create", "idem-2"),
+	}
+	for _, variant := range variants {
+		require.NotEqual(t, base, variant)
+	}
+	require.NotEqual(
+		t,
+		commandReplayScopeKey("test.command.checkout", "ab", "c", "quote:create", "idem-1"),
+		commandReplayScopeKey("test.command.checkout", "a", "bc", "quote:create", "idem-1"),
+	)
+}
+
 func TestCommandReplayRepositoryMarkTerminalStates(t *testing.T) {
 	db := newCommandReplayTestDB(t)
 	repo := NewCommandReplayRepository(db)
 	ctx := context.Background()
 	expiresAt := time.Now().Add(time.Hour)
 
-	succeededRecord := newPersistenceTestCommandReplayRecord("test.command.checkout", "quote:create", "idem-success", expiresAt)
+	succeededRecord := newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_123", "quote:create", "idem-success", expiresAt)
 	require.NoError(t, repo.Create(ctx, succeededRecord))
 	succeededAt := time.Now().Add(time.Minute)
 	require.NoError(t, repo.MarkSucceeded(ctx, succeededRecord.ID, json.RawMessage(`{"quote_no":"quote_1"}`), succeededAt))
 
-	loaded, err := repo.FindByScope(ctx, "test.command.checkout", "quote:create", "idem-success")
+	loaded, err := repo.FindByScope(ctx, "test.command.checkout", "identity", "user_123", "quote:create", "idem-success")
 	require.NoError(t, err)
 	require.NotNil(t, loaded)
 	require.Equal(t, CommandReplayStatusSucceeded, loaded.Status)
@@ -88,12 +115,12 @@ func TestCommandReplayRepositoryMarkTerminalStates(t *testing.T) {
 	err = repo.MarkFailed(ctx, succeededRecord.ID, "COMMERCE_QUOTE_FAILED", http.StatusConflict, json.RawMessage(`{"error":"failed"}`), time.Now().Add(2*time.Minute))
 	require.Error(t, err)
 
-	failedRecord := newPersistenceTestCommandReplayRecord("test.command.checkout", "quote:create", "idem-failed", expiresAt)
+	failedRecord := newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_123", "quote:create", "idem-failed", expiresAt)
 	require.NoError(t, repo.Create(ctx, failedRecord))
 	failedAt := time.Now().Add(3 * time.Minute)
 	require.NoError(t, repo.MarkFailed(ctx, failedRecord.ID, " COMMERCE_QUOTE_FAILED ", http.StatusConflict, json.RawMessage(`{"error":"failed"}`), failedAt))
 
-	loaded, err = repo.FindByScope(ctx, "test.command.checkout", "quote:create", "idem-failed")
+	loaded, err = repo.FindByScope(ctx, "test.command.checkout", "identity", "user_123", "quote:create", "idem-failed")
 	require.NoError(t, err)
 	require.NotNil(t, loaded)
 	require.Equal(t, CommandReplayStatusFailed, loaded.Status)
@@ -116,13 +143,13 @@ func TestCommandReplayRepositoryJoinsAmbientTransaction(t *testing.T) {
 	rollbackErr := errors.New("rollback command idempotency transaction")
 
 	err := manager.WithTransaction(ctx, func(txCtx context.Context) error {
-		record := newPersistenceTestCommandReplayRecord("test.command.checkout", "quote:create", "idem-rollback", time.Now().Add(time.Hour))
+		record := newPersistenceTestCommandReplayRecord("test.command.checkout", "identity", "user_123", "quote:create", "idem-rollback", time.Now().Add(time.Hour))
 		require.NoError(t, repo.Create(txCtx, record))
 		return rollbackErr
 	})
 	require.ErrorIs(t, err, rollbackErr)
 
-	found, err := repo.FindByScope(ctx, "test.command.checkout", "quote:create", "idem-rollback")
+	found, err := repo.FindByScope(ctx, "test.command.checkout", "identity", "user_123", "quote:create", "idem-rollback")
 	require.NoError(t, err)
 	require.Nil(t, found)
 }
@@ -147,8 +174,8 @@ func createCommandReplayRecordSchema(t *testing.T, db *gorm.DB) {
 			command_scope TEXT NOT NULL,
 			idempotency_key TEXT NOT NULL,
 			request_hash TEXT NOT NULL,
-			principal_type TEXT,
-			principal_ref TEXT,
+			principal_type TEXT NOT NULL,
+			principal_ref TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'started',
 			response_payload TEXT NOT NULL DEFAULT '{}',
 			error_code TEXT,
@@ -166,14 +193,16 @@ func createCommandReplayRecordSchema(t *testing.T, db *gorm.DB) {
 		)
 	`).Error)
 	require.NoError(t, db.Exec(`
-		CREATE UNIQUE INDEX uk_sys_command_replay_records_namespace_scope_key
-		ON sys_command_replay_records (namespace, command_scope, idempotency_key)
+		CREATE UNIQUE INDEX uk_sys_command_replay_records_principal_scope_key
+		ON sys_command_replay_records (namespace, principal_type, principal_ref, command_scope, idempotency_key)
 	`).Error)
 }
 
-func newPersistenceTestCommandReplayRecord(namespace, commandScope, idempotencyKey string, expiresAt time.Time) *CommandReplayRecord {
+func newPersistenceTestCommandReplayRecord(namespace, principalType, principalRef, commandScope, idempotencyKey string, expiresAt time.Time) *CommandReplayRecord {
 	return &CommandReplayRecord{
 		Namespace:       namespace,
+		PrincipalType:   principalType,
+		PrincipalRef:    principalRef,
 		CommandScope:    commandScope,
 		IdempotencyKey:  idempotencyKey,
 		RequestHash:     strings.Repeat("a", 64),

package/dist/resources/templates/go-backend/internal/core/commandreplay/repository.go

@@ -8,8 +8,8 @@ import (
 
 // CommandReplayRepository 命令幂等回放仓储接口。
 type CommandReplayRepository interface {
-	FindByScope(ctx context.Context, namespace, commandScope, idempotencyKey string) (*CommandReplayRecord, error)
-	TryAcquireScopeLock(ctx context.Context, namespace, commandScope, idempotencyKey string) (bool, error)
+	FindByScope(ctx context.Context, namespace, principalType, principalRef, commandScope, idempotencyKey string) (*CommandReplayRecord, error)
+	TryAcquireScopeLock(ctx context.Context, namespace, principalType, principalRef, commandScope, idempotencyKey string) (bool, error)
 	Create(ctx context.Context, record *CommandReplayRecord) error
 	MarkSucceeded(ctx context.Context, id int64, responsePayload json.RawMessage, completedAt time.Time) error
 	MarkFailed(ctx context.Context, id int64, errorCode string, errorStatus int, responsePayload json.RawMessage, completedAt time.Time) error

package/dist/resources/templates/go-backend/internal/core/commandreplay/service.go

@@ -74,6 +74,8 @@ func (s *CommandReplayService) Execute(ctx context.Context, req CommandReplayBeg
 		acquired, lockErr := s.repo.TryAcquireScopeLock(
 			txCtx,
 			normalized.namespace,
+			normalized.principalType,
+			normalized.principalRef,
 			normalized.commandScope,
 			normalized.idempotencyKey,
 		)
@@ -87,6 +89,8 @@ func (s *CommandReplayService) Execute(ctx context.Context, req CommandReplayBeg
 		existing, findErr := s.repo.FindByScope(
 			txCtx,
 			normalized.namespace,
+			normalized.principalType,
+			normalized.principalRef,
 			normalized.commandScope,
 			normalized.idempotencyKey,
 		)
@@ -112,8 +116,8 @@ func (s *CommandReplayService) Execute(ctx context.Context, req CommandReplayBeg
 			CommandScope:    normalized.commandScope,
 			IdempotencyKey:  normalized.idempotencyKey,
 			RequestHash:     normalized.requestHash,
-			PrincipalType:   cloneStringPtr(normalized.principalType),
-			PrincipalRef:    cloneStringPtr(normalized.principalRef),
+			PrincipalType:   normalized.principalType,
+			PrincipalRef:    normalized.principalRef,
 			Status:          CommandReplayStatusStarted,
 			ResponsePayload: json.RawMessage(`{}`),
 			ExpiresAt:       expiresAt,
@@ -126,6 +130,8 @@ func (s *CommandReplayService) Execute(ctx context.Context, req CommandReplayBeg
 			duplicate, reloadErr := s.repo.FindByScope(
 				txCtx,
 				normalized.namespace,
+				normalized.principalType,
+				normalized.principalRef,
 				normalized.commandScope,
 				normalized.idempotencyKey,
 			)
@@ -219,14 +225,14 @@ func (s *CommandReplayService) BeginExternal(
 	var lease *CommandReplayExternalLease
 	err = s.withTransaction(ctx, func(txCtx context.Context) error {
 		now := s.now().UTC()
-		acquired, lockErr := s.repo.TryAcquireScopeLock(txCtx, normalized.namespace, normalized.commandScope, normalized.idempotencyKey)
+		acquired, lockErr := s.repo.TryAcquireScopeLock(txCtx, normalized.namespace, normalized.principalType, normalized.principalRef, normalized.commandScope, normalized.idempotencyKey)
 		if lockErr != nil {
 			return apierror.Internal("Failed to acquire command replay scope lock")
 		}
 		if !acquired {
 			return apierror.Conflict(errCodeCommandReplayInProgress, "Command replay is already in progress")
 		}
-		existing, findErr := s.repo.FindByScope(txCtx, normalized.namespace, normalized.commandScope, normalized.idempotencyKey)
+		existing, findErr := s.repo.FindByScope(txCtx, normalized.namespace, normalized.principalType, normalized.principalRef, normalized.commandScope, normalized.idempotencyKey)
 		if findErr != nil {
 			return apierror.Internal("Failed to load command replay record")
 		}
@@ -514,7 +520,7 @@ func newCommandReplayRecord(normalized *normalizedCommandReplayBeginRequest, now
 	return &CommandReplayRecord{
 		Namespace: normalized.namespace, CommandScope: normalized.commandScope,
 		IdempotencyKey: normalized.idempotencyKey, RequestHash: normalized.requestHash,
-		PrincipalType: cloneStringPtr(normalized.principalType), PrincipalRef: cloneStringPtr(normalized.principalRef),
+		PrincipalType: normalized.principalType, PrincipalRef: normalized.principalRef,
 		Status: CommandReplayStatusStarted, ResponsePayload: json.RawMessage(`{}`),
 		ExpiresAt: now.Add(normalized.ttl), Metadata: normalized.metadata,
 	}
@@ -609,17 +615,14 @@ func normalizeCommandReplayBeginRequest(req CommandReplayBeginRequest) (*normali
 	if err != nil {
 		return nil, err
 	}
-	principalType, err := normalizeOptionalString("principalType", req.PrincipalType, maxPrincipalTypeLength)
+	principalType, err := normalizeRequiredString("principalType", req.PrincipalType, maxPrincipalTypeLength)
 	if err != nil {
 		return nil, err
 	}
-	principalRef, err := normalizeOptionalString("principalRef", req.PrincipalRef, maxPrincipalRefLength)
+	principalRef, err := normalizeRequiredString("principalRef", req.PrincipalRef, maxPrincipalRefLength)
 	if err != nil {
 		return nil, err
 	}
-	if (principalType == nil) != (principalRef == nil) {
-		return nil, apierror.BadRequest(apierror.CodeValidationFailed, "principalType and principalRef must be provided together")
-	}
 	ttl := req.TTL
 	if ttl <= 0 {
 		ttl = defaultCommandReplayTTL
@@ -789,20 +792,6 @@ func normalizeRequiredString(fieldName, value string, maxLength int) (string, er
 	return normalized, nil
 }
 
-func normalizeOptionalString(fieldName string, value *string, maxLength int) (*string, error) {
-	if value == nil {
-		return nil, nil
-	}
-	normalized := strings.TrimSpace(*value)
-	if normalized == "" {
-		return nil, apierror.BadRequest(apierror.CodeValidationFailed, fieldName+" must not be blank")
-	}
-	if utf8.RuneCountInString(normalized) > maxLength {
-		return nil, apierror.BadRequest(apierror.CodeValidationFailed, fieldName+" is too long")
-	}
-	return &normalized, nil
-}
-
 func (s *CommandReplayService) markSucceeded(ctx context.Context, recordID int64, responsePayload json.RawMessage, completedAt time.Time) error {
 	if markErr := s.repo.MarkSucceeded(ctx, recordID, responsePayload, completedAt); markErr != nil {
 		return apierror.Internal("Failed to mark command replay record as succeeded")

package/dist/resources/templates/go-backend/internal/core/commandreplay/service_persistence_test.go

@@ -46,7 +46,7 @@ func TestCommandReplayExecuteStandaloneCommitsBusinessFailure(t *testing.T) {
 		t.Fatalf("Execute() result = %#v, want failed result", result)
 	}
 
-	stored, err := repo.FindByScope(ctx, "test.command.replay", "quote:123", "key-123")
+	stored, err := repo.FindByScope(ctx, "test.command.replay", "identity", "user_123", "quote:123", "key-123")
 	if err != nil {
 		t.Fatalf("FindByScope() error = %v", err)
 	}
@@ -101,7 +101,7 @@ func TestCommandReplayExecuteStandaloneRollsBackInfrastructureError(t *testing.T
 		t.Fatalf("Execute() error = %v, want infraErr", err)
 	}
 
-	stored, err := repo.FindByScope(ctx, "test.command.replay", "quote:123", "key-123")
+	stored, err := repo.FindByScope(ctx, "test.command.replay", "identity", "user_123", "quote:123", "key-123")
 	if err != nil {
 		t.Fatalf("FindByScope() error = %v", err)
 	}
@@ -147,7 +147,7 @@ func TestCommandReplayExecuteJoinsOuterTransactionRollback(t *testing.T) {
 		t.Fatalf("WithTransaction() error = %v, want rollbackErr", err)
 	}
 
-	stored, err := repo.FindByScope(ctx, "test.command.replay", "quote:123", "key-123")
+	stored, err := repo.FindByScope(ctx, "test.command.replay", "identity", "user_123", "quote:123", "key-123")
 	if err != nil {
 		t.Fatalf("FindByScope() error = %v", err)
 	}
@@ -214,7 +214,7 @@ func TestCommandReplayExecuteRejectsConcurrentDuplicateOnPostgres(t *testing.T)
 		t.Fatalf("business executions = %d, want 1", executions.Load())
 	}
 
-	stored, err := repo.FindByScope(ctx, "test.command.replay", "quote:123", "key-123")
+	stored, err := repo.FindByScope(ctx, "test.command.replay", "identity", "user_123", "quote:123", "key-123")
 	if err != nil {
 		t.Fatalf("FindByScope() error = %v", err)
 	}
@@ -223,6 +223,89 @@ func TestCommandReplayExecuteRejectsConcurrentDuplicateOnPostgres(t *testing.T)
 	}
 }
 
+func TestCommandReplayExecuteAllowsConcurrentSameKeyForDifferentPrincipalsOnPostgres(t *testing.T) {
+	db := openPersistentCommandReplayPostgres(t)
+	repo := commandreplay.NewCommandReplayRepository(db)
+	service := commandreplay.NewCommandReplayService(repo, database.NewTransactionManager(db))
+	ctx := context.Background()
+	firstStarted := make(chan struct{})
+	releaseFirst := make(chan struct{})
+	firstDone := make(chan error, 1)
+	secondDone := make(chan error, 1)
+	releasedFirst := false
+	defer func() {
+		if !releasedFirst {
+			close(releaseFirst)
+		}
+	}()
+	var executions atomic.Int32
+
+	go func() {
+		_, err := service.Execute(ctx, persistentCommandReplayRequest(json.RawMessage(`{"amount":100}`)), func(context.Context, *commandreplay.CommandReplayRecord) (*commandreplay.CommandReplayCommandResult, error) {
+			executions.Add(1)
+			close(firstStarted)
+			<-releaseFirst
+			return &commandreplay.CommandReplayCommandResult{
+				Status:          commandreplay.CommandReplayStatusSucceeded,
+				ResponsePayload: json.RawMessage(`{"status":"first"}`),
+			}, nil
+		})
+		firstDone <- err
+	}()
+
+	select {
+	case <-firstStarted:
+	case <-time.After(5 * time.Second):
+		t.Fatal("first principal did not enter its transaction")
+	}
+
+	secondRequest := persistentCommandReplayRequest(json.RawMessage(`{"amount":100}`))
+	secondRequest.PrincipalRef = "user_456"
+	go func() {
+		_, err := service.Execute(ctx, secondRequest, func(context.Context, *commandreplay.CommandReplayRecord) (*commandreplay.CommandReplayCommandResult, error) {
+			executions.Add(1)
+			return &commandreplay.CommandReplayCommandResult{
+				Status:          commandreplay.CommandReplayStatusSucceeded,
+				ResponsePayload: json.RawMessage(`{"status":"second"}`),
+			}, nil
+		})
+		secondDone <- err
+	}()
+
+	select {
+	case err := <-secondDone:
+		if err != nil {
+			t.Fatalf("second principal Execute() error = %v", err)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("second principal was blocked by another principal's scope lock")
+	}
+	close(releaseFirst)
+	releasedFirst = true
+
+	select {
+	case err := <-firstDone:
+		if err != nil {
+			t.Fatalf("first principal Execute() error = %v", err)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("first principal did not complete")
+	}
+	if executions.Load() != 2 {
+		t.Fatalf("business executions = %d, want 2", executions.Load())
+	}
+
+	for _, principalRef := range []string{"user_123", "user_456"} {
+		stored, err := repo.FindByScope(ctx, "test.command.replay", "identity", principalRef, "quote:123", "key-123")
+		if err != nil {
+			t.Fatalf("FindByScope(%s) error = %v", principalRef, err)
+		}
+		if stored == nil || stored.Status != commandreplay.CommandReplayStatusSucceeded {
+			t.Fatalf("stored record for %s = %#v, want succeeded", principalRef, stored)
+		}
+	}
+}
+
 func newPersistentCommandReplayService(t *testing.T) (*commandreplay.CommandReplayService, commandreplay.CommandReplayRepository) {
 	t.Helper()
 	service, repo, _, _ := newPersistentCommandReplayFixture(t)
@@ -248,13 +331,15 @@ type sqliteCommandReplayRepository struct {
 	commandreplay.CommandReplayRepository
 }
 
-func (r sqliteCommandReplayRepository) TryAcquireScopeLock(ctx context.Context, namespace, commandScope, idempotencyKey string) (bool, error) {
+func (r sqliteCommandReplayRepository) TryAcquireScopeLock(ctx context.Context, namespace, principalType, principalRef, commandScope, idempotencyKey string) (bool, error) {
 	return true, nil
 }
 
 func persistentCommandReplayRequest(payload json.RawMessage) commandreplay.CommandReplayBeginRequest {
 	return commandreplay.CommandReplayBeginRequest{
 		Namespace:      "test.command.replay",
+		PrincipalType:  "identity",
+		PrincipalRef:   "user_123",
 		CommandScope:   "quote:123",
 		IdempotencyKey: "key-123",
 		RequestPayload: payload,
@@ -275,8 +360,8 @@ func createPersistentCommandReplayRecordSchema(t *testing.T, db *gorm.DB) {
 			command_scope TEXT NOT NULL,
 			idempotency_key TEXT NOT NULL,
 			request_hash TEXT NOT NULL,
-			principal_type TEXT,
-			principal_ref TEXT,
+			principal_type TEXT NOT NULL,
+			principal_ref TEXT NOT NULL,
 			status TEXT NOT NULL DEFAULT 'started',
 			response_payload TEXT NOT NULL DEFAULT '{}',
 			error_code TEXT,
@@ -296,8 +381,8 @@ func createPersistentCommandReplayRecordSchema(t *testing.T, db *gorm.DB) {
 		t.Fatalf("create command replay schema: %v", err)
 	}
 	if err := db.Exec(`
-		CREATE UNIQUE INDEX uk_sys_command_replay_records_namespace_scope_key
-		ON sys_command_replay_records (namespace, command_scope, idempotency_key)
+		CREATE UNIQUE INDEX uk_sys_command_replay_records_principal_scope_key
+		ON sys_command_replay_records (namespace, principal_type, principal_ref, command_scope, idempotency_key)
 	`).Error; err != nil {
 		t.Fatalf("create command replay unique index: %v", err)
 	}
@@ -381,8 +466,8 @@ func createPersistentCommandReplayPostgresSchema(t *testing.T, db *gorm.DB) {
 			command_scope VARCHAR(128) NOT NULL,
 			idempotency_key VARCHAR(191) NOT NULL,
 			request_hash CHAR(64) NOT NULL,
-			principal_type VARCHAR(32),
-			principal_ref VARCHAR(64),
+			principal_type VARCHAR(32) NOT NULL,
+			principal_ref VARCHAR(64) NOT NULL,
 			status VARCHAR(20) NOT NULL DEFAULT 'started',
 			response_payload JSONB NOT NULL DEFAULT '{}'::jsonb,
 			error_code VARCHAR(120),
@@ -397,8 +482,8 @@ func createPersistentCommandReplayPostgresSchema(t *testing.T, db *gorm.DB) {
 			external_attempt_count INTEGER NOT NULL DEFAULT 0,
 			external_last_error_code VARCHAR(120),
 			metadata JSONB NOT NULL DEFAULT '{}'::jsonb,
-			CONSTRAINT uk_sys_command_replay_records_namespace_scope_key
-				UNIQUE (namespace, command_scope, idempotency_key)
+			CONSTRAINT uk_sys_command_replay_records_principal_scope_key
+				UNIQUE (namespace, principal_type, principal_ref, command_scope, idempotency_key)
 		)
 	`).Error; err != nil {
 		t.Fatalf("create PostgreSQL command replay schema: %v", err)