@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/core/clock/runtime_clock_test.go

@@ -0,0 +1,98 @@
+package clock
+
+import (
+	"fmt"
+	"testing"
+	"time"
+
+	"go.uber.org/zap"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+
+	"{{module}}/internal/core/config"
+)
+
+func TestRuntimeClockFreezeAdvanceReset(t *testing.T) {
+	db := openRuntimeClockTestDB(t)
+	clock := NewRuntimeClock(zap.NewNop(), db, &config.Config{
+		App: config.AppConfig{Env: "development"},
+	})
+
+	base := time.Date(2026, 4, 15, 12, 0, 0, 0, time.UTC)
+	state, err := clock.Freeze(t.Context(), base, "freeze for test", int64Ptr(1))
+	if err != nil {
+		t.Fatalf("Freeze() error = %v", err)
+	}
+	if state.Mode != RuntimeModeFrozen {
+		t.Fatalf("Freeze() mode = %s, want %s", state.Mode, RuntimeModeFrozen)
+	}
+	if got := clock.Now(); !got.Equal(base) {
+		t.Fatalf("Now() after freeze = %v, want %v", got, base)
+	}
+
+	advanced, err := clock.Advance(t.Context(), 24*time.Hour, "advance one day", int64Ptr(2))
+	if err != nil {
+		t.Fatalf("Advance() error = %v", err)
+	}
+	wantAdvanced := base.Add(24 * time.Hour)
+	if advanced.FrozenAt == nil || !advanced.FrozenAt.Equal(wantAdvanced) {
+		t.Fatalf("Advance() frozenAt = %v, want %v", advanced.FrozenAt, wantAdvanced)
+	}
+	if got := clock.Now(); !got.Equal(wantAdvanced) {
+		t.Fatalf("Now() after advance = %v, want %v", got, wantAdvanced)
+	}
+
+	reset, err := clock.Reset(t.Context(), "back to realtime", int64Ptr(3))
+	if err != nil {
+		t.Fatalf("Reset() error = %v", err)
+	}
+	if reset.Mode != RuntimeModeRealtime {
+		t.Fatalf("Reset() mode = %s, want %s", reset.Mode, RuntimeModeRealtime)
+	}
+	if reset.FrozenAt != nil {
+		t.Fatalf("Reset() frozenAt = %v, want nil", reset.FrozenAt)
+	}
+}
+
+func TestRuntimeClockProductionRejectsControl(t *testing.T) {
+	db := openRuntimeClockTestDB(t)
+	clock := NewRuntimeClock(zap.NewNop(), db, &config.Config{
+		App: config.AppConfig{Env: "production"},
+	})
+
+	if clock.IsControllable() {
+		t.Fatalf("IsControllable() = true, want false")
+	}
+	if _, err := clock.Freeze(t.Context(), time.Now().UTC(), "should fail", nil); err == nil {
+		t.Fatalf("Freeze() error = nil, want error")
+	}
+}
+
+func openRuntimeClockTestDB(t *testing.T) *gorm.DB {
+	t.Helper()
+
+	dsn := fmt.Sprintf("file:%s?mode=memory&cache=shared&_loc=UTC", t.Name())
+	db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("gorm.Open() error = %v", err)
+	}
+	if err := db.Exec(`
+		CREATE TABLE sys_runtime_clock_controls (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			scope TEXT NOT NULL UNIQUE,
+			mode TEXT NOT NULL,
+			frozen_at DATETIME,
+			reason TEXT,
+			updated_by INTEGER,
+			created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+			updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+		)
+	`).Error; err != nil {
+		t.Fatalf("create runtime clock table error = %v", err)
+	}
+	return db
+}
+
+func int64Ptr(value int64) *int64 {
+	return &value
+}

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

@@ -0,0 +1,6 @@
+package commandreplay
+
+import "errors"
+
+// ErrCommandReplayRecordExists 表示同一命令幂等作用域已存在回放记录。
+var ErrCommandReplayRecordExists = errors.New("command replay record already exists")

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

@@ -0,0 +1,90 @@
+package commandreplay
+
+import (
+	"encoding/json"
+	"time"
+
+	"{{module}}/internal/core/database"
+)
+
+// CommandReplayStatus 命令幂等记录状态。
+type CommandReplayStatus string
+
+const (
+	CommandReplayStatusStarted   CommandReplayStatus = "started"
+	CommandReplayStatusSucceeded CommandReplayStatus = "succeeded"
+	CommandReplayStatusFailed    CommandReplayStatus = "failed"
+)
+
+// IsValid 判断命令幂等记录状态是否合法。
+func (s CommandReplayStatus) IsValid() bool {
+	switch s {
+	case CommandReplayStatusStarted, CommandReplayStatusSucceeded, CommandReplayStatusFailed:
+		return true
+	default:
+		return false
+	}
+}
+
+// IsTerminal 判断命令幂等记录状态是否终态。
+func (s CommandReplayStatus) IsTerminal() bool {
+	return s == CommandReplayStatusSucceeded || s == CommandReplayStatusFailed
+}
+
+// CommandReplayRecord 跨领域命令幂等回放记录。
+type CommandReplayRecord struct {
+	database.BaseModel
+	Namespace       string              `gorm:"column:namespace;type:varchar(200);not null;uniqueIndex:uk_sys_command_replay_records_namespace_scope_key,priority:1;comment:命令所有者全局命名空间" json:"namespace"`
+	CommandScope    string              `gorm:"column:command_scope;type:varchar(128);not null;uniqueIndex:uk_sys_command_replay_records_namespace_scope_key,priority:2;comment:命令幂等作用域" json:"command_scope"`
+	IdempotencyKey  string              `gorm:"column:idempotency_key;type:varchar(191);not null;uniqueIndex:uk_sys_command_replay_records_namespace_scope_key,priority:3;comment:请求幂等键" json:"idempotency_key"`
+	RequestHash     string              `gorm:"column:request_hash;type:varchar(64);not null;comment:请求载荷指纹" json:"request_hash"`
+	PrincipalType   *string             `gorm:"column:principal_type;type:varchar(32);comment:请求主体类型" json:"principal_type"`
+	PrincipalRef    *string             `gorm:"column:principal_ref;type:varchar(64);comment:请求主体公开引用" json:"principal_ref"`
+	Status          CommandReplayStatus `gorm:"column:status;type:varchar(20);not null;default:'started';comment:命令执行状态" json:"status"`
+	ResponsePayload json.RawMessage     `gorm:"column:response_payload;type:jsonb;not null;default:'{}';comment:回放响应载荷" json:"response_payload"`
+	ErrorCode       *string             `gorm:"column:error_code;type:varchar(120);comment:失败错误码" json:"error_code"`
+	ErrorStatus     *int                `gorm:"column:error_status;comment:失败 HTTP 状态码" json:"error_status"`
+	ExpiresAt       time.Time           `gorm:"column:expires_at;type:timestamptz(3);not null;comment:幂等记录过期时间" json:"expires_at"`
+	CompletedAt     *time.Time          `gorm:"column:completed_at;type:timestamptz(3);comment:命令完成时间" json:"completed_at"`
+	Metadata        json.RawMessage     `gorm:"column:metadata;type:jsonb;not null;default:'{}';comment:扩展元数据" json:"metadata"`
+	// ExternalReferenceType 是外部执行恢复处理器类型。
+	ExternalReferenceType *string `gorm:"column:external_reference_type;type:varchar(64);comment:外部执行恢复处理器类型" json:"-"`
+	// ExternalReferenceNo 是外部执行恢复业务引用。
+	ExternalReferenceNo *string `gorm:"column:external_reference_no;type:varchar(191);comment:外部执行恢复业务引用" json:"-"`
+	// ExecutionTokenHash 是当前外部执行租约令牌摘要。
+	ExecutionTokenHash *string `gorm:"column:execution_token_hash;type:char(64);comment:外部副作用执行租约令牌摘要" json:"-"`
+	// LeaseExpiresAt 是当前外部执行租约截止时间。
+	LeaseExpiresAt *time.Time `gorm:"column:lease_expires_at;type:timestamptz(3);comment:外部副作用执行租约截止时间" json:"-"`
+	// ExternalNextRecoveryAt 是外部副作用下次恢复时间。
+	ExternalNextRecoveryAt *time.Time `gorm:"column:external_next_recovery_at;type:timestamptz(3);comment:外部副作用下次恢复时间" json:"-"`
+	// ExternalAttemptCount 是外部执行领取次数。
+	ExternalAttemptCount int `gorm:"column:external_attempt_count;not null;default:0;comment:外部副作用执行领取次数" json:"-"`
+	// ExternalLastErrorCode 是最近一次规范化恢复错误码。
+	ExternalLastErrorCode *string `gorm:"column:external_last_error_code;type:varchar(120);comment:最近一次规范化恢复错误编码" json:"-"`
+}
+
+// TableName 指定跨领域命令回放记录表。
+func (CommandReplayRecord) TableName() string {
+	return "sys_command_replay_records"
+}
+
+// IsExpiredAt 判断记录在指定时间是否已过期。
+func (r *CommandReplayRecord) IsExpiredAt(at time.Time) bool {
+	return r != nil && !at.Before(r.ExpiresAt)
+}
+
+// MatchesRequestHash 判断请求载荷指纹是否一致。
+func (r *CommandReplayRecord) MatchesRequestHash(hash string) bool {
+	return r != nil && r.RequestHash == hash
+}
+
+// HasExternalReservation 判断记录是否持有完整外部恢复引用。
+func (r *CommandReplayRecord) HasExternalReservation() bool {
+	return r != nil && r.ExternalReferenceType != nil && *r.ExternalReferenceType != "" &&
+		r.ExternalReferenceNo != nil && *r.ExternalReferenceNo != ""
+}
+
+// HasActiveExternalLease 判断记录在指定时间是否仍被执行者租用。
+func (r *CommandReplayRecord) HasActiveExternalLease(at time.Time) bool {
+	return r != nil && r.ExecutionTokenHash != nil && r.LeaseExpiresAt != nil && at.Before(*r.LeaseExpiresAt)
+}

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

@@ -0,0 +1,79 @@
+package commandreplay
+
+import (
+	"testing"
+	"time"
+)
+
+func TestCommandReplayStatusValidity(t *testing.T) {
+	tests := []struct {
+		name   string
+		status CommandReplayStatus
+		want   bool
+	}{
+		{name: "started", status: CommandReplayStatusStarted, want: true},
+		{name: "succeeded", status: CommandReplayStatusSucceeded, want: true},
+		{name: "failed", status: CommandReplayStatusFailed, want: true},
+		{name: "unknown", status: CommandReplayStatus("unknown"), want: false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.status.IsValid(); got != tt.want {
+				t.Fatalf("IsValid() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCommandReplayStatusTerminal(t *testing.T) {
+	tests := []struct {
+		name   string
+		status CommandReplayStatus
+		want   bool
+	}{
+		{name: "started", status: CommandReplayStatusStarted, want: false},
+		{name: "succeeded", status: CommandReplayStatusSucceeded, want: true},
+		{name: "failed", status: CommandReplayStatusFailed, want: true},
+		{name: "unknown", status: CommandReplayStatus("unknown"), want: false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.status.IsTerminal(); got != tt.want {
+				t.Fatalf("IsTerminal() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCommandReplayRecordTableName(t *testing.T) {
+	var record CommandReplayRecord
+
+	if got := record.TableName(); got != "sys_command_replay_records" {
+		t.Fatalf("TableName() = %q, want %q", got, "sys_command_replay_records")
+	}
+}
+
+func TestCommandReplayRecordMatchesRequestHash(t *testing.T) {
+	record := &CommandReplayRecord{RequestHash: "hash-a"}
+
+	if !record.MatchesRequestHash("hash-a") {
+		t.Fatalf("MatchesRequestHash() = false, want true")
+	}
+	if record.MatchesRequestHash("hash-b") {
+		t.Fatalf("MatchesRequestHash() = true, want false")
+	}
+}
+
+func TestCommandReplayRecordIsExpiredAt(t *testing.T) {
+	expiresAt := time.Date(2026, 5, 28, 10, 0, 0, 0, time.UTC)
+	record := &CommandReplayRecord{ExpiresAt: expiresAt}
+
+	if record.IsExpiredAt(expiresAt.Add(-time.Nanosecond)) {
+		t.Fatalf("IsExpiredAt() = true before expiry, want false")
+	}
+	if !record.IsExpiredAt(expiresAt) {
+		t.Fatalf("IsExpiredAt() = false at expiry, want true")
+	}
+}

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

@@ -0,0 +1,7 @@
+package commandreplay
+
+import (
+	"regexp"
+)
+
+var commandReplayNamespacePattern = regexp.MustCompile(`^[a-z][a-z0-9_-]*(\.[a-z][a-z0-9_-]*){2,7}$`)

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

@@ -0,0 +1,269 @@
+package commandreplay
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+	"time"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+
+	"{{module}}/internal/core/database"
+)
+
+var commandReplayRecordColumns = []string{
+	"id", "created_at", "updated_at",
+	"namespace", "command_scope", "idempotency_key",
+	"request_hash", "principal_type", "principal_ref", "status",
+	"response_payload", "error_code", "error_status", "expires_at", "completed_at", "metadata",
+	"external_reference_type", "external_reference_no", "execution_token_hash", "lease_expires_at",
+	"external_next_recovery_at", "external_attempt_count", "external_last_error_code",
+}
+
+type commandReplayRepository struct {
+	db *gorm.DB
+}
+
+// NewCommandReplayRepository 创建跨领域命令幂等回放仓储。
+func NewCommandReplayRepository(db *gorm.DB) CommandReplayRepository {
+	return &commandReplayRepository{db: db}
+}
+
+func (r *commandReplayRepository) FindByScope(ctx context.Context, namespace, commandScope, idempotencyKey string) (*CommandReplayRecord, error) {
+	var record CommandReplayRecord
+	err := database.GetDB(ctx, r.db).
+		Select(commandReplayRecordColumns).
+		Where("namespace = ?", strings.TrimSpace(namespace)).
+		Where("command_scope = ?", strings.TrimSpace(commandScope)).
+		Where("idempotency_key = ?", strings.TrimSpace(idempotencyKey)).
+		First(&record).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("find command replay record by scope: %w", err)
+	}
+	return &record, nil
+}
+
+func (r *commandReplayRepository) FindByIDForUpdate(ctx context.Context, id int64) (*CommandReplayRecord, error) {
+	var record CommandReplayRecord
+	err := database.GetDB(ctx, r.db).
+		Select(commandReplayRecordColumns).
+		Where("id = ?", id).
+		Clauses(clause.Locking{Strength: "UPDATE"}).
+		First(&record).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, fmt.Errorf("find command replay record for update: %w", err)
+	}
+	return &record, nil
+}
+
+func (r *commandReplayRepository) TryAcquireScopeLock(ctx context.Context, namespace, commandScope, idempotencyKey string) (bool, error) {
+	db := database.GetDB(ctx, r.db)
+	if db.Dialector.Name() != "postgres" {
+		return false, fmt.Errorf("unsupported database dialect for command replay scope lock: %s", db.Dialector.Name())
+	}
+
+	scopeKey := strings.Join([]string{
+		strings.TrimSpace(namespace),
+		strings.TrimSpace(commandScope),
+		strings.TrimSpace(idempotencyKey),
+	}, "\x1f")
+
+	var acquired bool
+	if err := db.Raw(
+		"SELECT pg_try_advisory_xact_lock(('x' || substr(md5(?), 1, 16))::bit(64)::bigint)",
+		scopeKey,
+	).Scan(&acquired).Error; err != nil {
+		return false, fmt.Errorf("try acquire command replay scope lock: %w", err)
+	}
+	return acquired, nil
+}
+
+func (r *commandReplayRepository) Create(ctx context.Context, record *CommandReplayRecord) error {
+	result := database.GetDB(ctx, r.db).
+		Clauses(clause.OnConflict{
+			Columns: []clause.Column{
+				{Name: "namespace"},
+				{Name: "command_scope"},
+				{Name: "idempotency_key"},
+			},
+			DoNothing: true,
+		}).
+		Create(record)
+	if result.Error != nil {
+		return fmt.Errorf("create command replay record: %w", result.Error)
+	}
+	if result.RowsAffected == 0 {
+		return ErrCommandReplayRecordExists
+	}
+	return nil
+}
+
+func (r *commandReplayRepository) MarkSucceeded(ctx context.Context, id int64, responsePayload json.RawMessage, completedAt time.Time) error {
+	result := database.GetDB(ctx, r.db).
+		Model(&CommandReplayRecord{}).
+		Where("id = ? AND status = ?", id, CommandReplayStatusStarted).
+		// 使用 map 原子写入 nil 与 JSON 字段，避免 struct 零值被 GORM 跳过。
+		Updates(map[string]any{
+			"status":           CommandReplayStatusSucceeded,
+			"response_payload": responsePayload,
+			"error_code":       nil,
+			"error_status":     nil,
+			"completed_at":     completedAt,
+		})
+	if result.Error != nil {
+		return fmt.Errorf("mark command replay record succeeded: %w", result.Error)
+	}
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("command replay record %d is not started", id)
+	}
+	return nil
+}
+
+func (r *commandReplayRepository) MarkFailed(ctx context.Context, id int64, errorCode string, errorStatus int, responsePayload json.RawMessage, completedAt time.Time) error {
+	if errorStatus < 400 || errorStatus > 599 {
+		return fmt.Errorf("invalid command idempotency error status: %d", errorStatus)
+	}
+	result := database.GetDB(ctx, r.db).
+		Model(&CommandReplayRecord{}).
+		Where("id = ? AND status = ?", id, CommandReplayStatusStarted).
+		// 使用 map 原子写入 nil 与 JSON 字段，避免 struct 零值被 GORM 跳过。
+		Updates(map[string]any{
+			"status":           CommandReplayStatusFailed,
+			"error_code":       strings.TrimSpace(errorCode),
+			"error_status":     errorStatus,
+			"response_payload": responsePayload,
+			"completed_at":     completedAt,
+		})
+	if result.Error != nil {
+		return fmt.Errorf("mark command replay record failed: %w", result.Error)
+	}
+	if result.RowsAffected == 0 {
+		return fmt.Errorf("command replay record %d is not started", id)
+	}
+	return nil
+}
+
+func (r *commandReplayRepository) StartExternalExecution(
+	ctx context.Context,
+	id int64,
+	referenceType, referenceNo, tokenHash string,
+	preparedResponsePayload json.RawMessage,
+	leaseExpiresAt time.Time,
+) error {
+	result := database.GetDB(ctx, r.db).
+		Model(&CommandReplayRecord{}).
+		Where("id = ? AND status = ? AND external_reference_no IS NULL", id, CommandReplayStatusStarted).
+		Updates(map[string]any{
+			"response_payload":          preparedResponsePayload,
+			"external_reference_type":   strings.TrimSpace(referenceType),
+			"external_reference_no":     strings.TrimSpace(referenceNo),
+			"execution_token_hash":      tokenHash,
+			"lease_expires_at":          leaseExpiresAt,
+			"external_next_recovery_at": leaseExpiresAt,
+			"external_attempt_count":    1,
+			"external_last_error_code":  nil,
+		})
+	return externalMutationResult(result, "start", id)
+}
+
+func (r *commandReplayRepository) ClaimExternalRecovery(
+	ctx context.Context,
+	id int64,
+	expectedRecoveryAt time.Time,
+	tokenHash string,
+	leaseExpiresAt time.Time,
+) error {
+	result := database.GetDB(ctx, r.db).
+		Model(&CommandReplayRecord{}).
+		Where("id = ? AND status = ?", id, CommandReplayStatusStarted).
+		Where("external_reference_no IS NOT NULL AND external_next_recovery_at = ?", expectedRecoveryAt).
+		Where("external_next_recovery_at <= CURRENT_TIMESTAMP").
+		Where("lease_expires_at IS NULL OR lease_expires_at <= CURRENT_TIMESTAMP").
+		Updates(map[string]any{
+			"execution_token_hash":      tokenHash,
+			"lease_expires_at":          leaseExpiresAt,
+			"external_next_recovery_at": leaseExpiresAt,
+			"external_attempt_count":    gorm.Expr("external_attempt_count + 1"),
+			"external_last_error_code":  nil,
+		})
+	return externalMutationResult(result, "claim", id)
+}
+
+func (r *commandReplayRepository) DeferExternalExecution(
+	ctx context.Context,
+	id int64,
+	tokenHash, errorCode string,
+	nextRecoveryAt time.Time,
+) error {
+	result := database.GetDB(ctx, r.db).
+		Model(&CommandReplayRecord{}).
+		Where("id = ? AND status = ? AND execution_token_hash = ?", id, CommandReplayStatusStarted, tokenHash).
+		Where("lease_expires_at > CURRENT_TIMESTAMP").
+		Updates(map[string]any{
+			"execution_token_hash":      nil,
+			"lease_expires_at":          nil,
+			"external_next_recovery_at": nextRecoveryAt,
+			"external_last_error_code":  strings.TrimSpace(errorCode),
+		})
+	return externalMutationResult(result, "defer", id)
+}
+
+func (r *commandReplayRepository) ClearExternalExecution(ctx context.Context, id int64, tokenHash string) error {
+	result := database.GetDB(ctx, r.db).
+		Model(&CommandReplayRecord{}).
+		Where("id = ? AND status = ? AND execution_token_hash = ?", id, CommandReplayStatusStarted, tokenHash).
+		Where("lease_expires_at > CURRENT_TIMESTAMP").
+		Updates(map[string]any{
+			"external_reference_type":   nil,
+			"external_reference_no":     nil,
+			"execution_token_hash":      nil,
+			"lease_expires_at":          nil,
+			"external_next_recovery_at": nil,
+			"external_attempt_count":    0,
+			"external_last_error_code":  nil,
+		})
+	return externalMutationResult(result, "clear", id)
+}
+
+func (r *commandReplayRepository) ListDueExternalRecoveries(
+	ctx context.Context,
+	referenceType string,
+	at time.Time,
+	limit int,
+) ([]CommandReplayRecord, error) {
+	if limit < 1 || limit > maxExternalRecoveryBatchSize {
+		return nil, fmt.Errorf("external recovery limit must be between 1 and 500")
+	}
+	var records []CommandReplayRecord
+	err := database.GetDB(ctx, r.db).
+		Select(commandReplayRecordColumns).
+		Where("external_reference_type = ? AND status = ?", strings.TrimSpace(referenceType), CommandReplayStatusStarted).
+		Where("external_reference_no IS NOT NULL AND external_next_recovery_at <= ?", at).
+		Where("lease_expires_at IS NULL OR lease_expires_at <= ?", at).
+		Order("external_next_recovery_at ASC, id ASC").
+		Limit(limit).
+		Find(&records).Error
+	if err != nil {
+		return nil, fmt.Errorf("list due external command recoveries: %w", err)
+	}
+	return records, nil
+}
+
+func externalMutationResult(result *gorm.DB, action string, id int64) error {
+	if result.Error != nil {
+		return fmt.Errorf("%s external command execution: %w", action, result.Error)
+	}
+	if result.RowsAffected != 1 {
+		return fmt.Errorf("cannot %s external command execution for record %d", action, id)
+	}
+	return nil
+}