@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/core/outbox/writer_postgres_test.go

@@ -0,0 +1,170 @@
+package outbox
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/lib/pq"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+
+	"{{module}}/internal/core/database"
+)
+
+func TestWriterPersistsCanonicalAudienceJSONOnPostgres(t *testing.T) {
+	dsn := strings.TrimSpace(os.Getenv("ONEX_TEST_POSTGRES_DSN"))
+	if dsn == "" {
+		t.Skip("ONEX_TEST_POSTGRES_DSN is not set")
+	}
+
+	connector, err := pq.NewConnector(dsn)
+	require.NoError(t, err)
+	sqlDB := sql.OpenDB(connector)
+	require.NoError(t, sqlDB.PingContext(context.Background()))
+	db, err := gorm.Open(postgres.New(postgres.Config{Conn: sqlDB}), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		require.NoError(t, sqlDB.Close())
+	})
+
+	txManager := database.NewTransactionManager(db)
+	writer := NewWriter(db, zap.NewNop())
+	testCases := []struct {
+		name     string
+		id       string
+		source   EventSource
+		audience EventAudience
+	}{
+		{
+			name:     "source product nil audience list",
+			id:       "00000000-0000-4000-8000-000000000101",
+			source:   ProductSource(" customer_operations_os "),
+			audience: EventAudience{Scope: AudienceScopeSourceProduct},
+		},
+		{
+			name:     "source product empty audience list",
+			id:       "00000000-0000-4000-8000-000000000102",
+			source:   ProductSource("customer_operations_os"),
+			audience: EventAudience{Scope: AudienceScopeSourceProduct, ProductCodes: []string{}},
+		},
+		{
+			name:     "targeted products are nonempty and sorted",
+			id:       "00000000-0000-4000-8000-000000000103",
+			source:   PlatformSource(),
+			audience: ProductsAudience("product_alpha", "customer_operations_os"),
+		},
+		{
+			name:   "zero source and audience become platform empty list",
+			id:     "00000000-0000-4000-8000-000000000104",
+			source: EventSource{},
+		},
+		{
+			name:     "platform explicit empty audience list",
+			id:       "00000000-0000-4000-8000-000000000105",
+			source:   PlatformSource(),
+			audience: EventAudience{Scope: AudienceScopePlatform, ProductCodes: []string{}},
+		},
+	}
+
+	err = txManager.WithTransaction(context.Background(), func(ctx context.Context) error {
+		tx := database.GetDB(ctx, db)
+		require.NoError(t, tx.Exec(`
+			CREATE TEMP TABLE sys_outbox_events (
+				id UUID DEFAULT gen_random_uuid() PRIMARY KEY,
+				outbox_ref VARCHAR(80) NOT NULL UNIQUE,
+				aggregate_type VARCHAR(100) NOT NULL,
+				aggregate_id VARCHAR(100) NOT NULL,
+				aggregate_version BIGINT,
+				source_product_code VARCHAR(50),
+				audience_scope VARCHAR(24) NOT NULL,
+				audience_product_codes JSONB NOT NULL CHECK (jsonb_typeof(audience_product_codes) = 'array'),
+				event_type VARCHAR(200) NOT NULL,
+				schema_version VARCHAR(40),
+				payload JSONB NOT NULL,
+				metadata JSONB,
+				audit_changes JSONB,
+				audit_meta JSONB,
+				occurred_at TIMESTAMPTZ NOT NULL,
+				created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+				status VARCHAR(20) NOT NULL DEFAULT 'pending',
+				locked_at TIMESTAMPTZ,
+				locked_by VARCHAR(100),
+				retry_count SMALLINT NOT NULL,
+				max_retries SMALLINT NOT NULL,
+				next_retry_at TIMESTAMPTZ,
+				last_error TEXT
+			) ON COMMIT DROP
+		`).Error)
+
+		for _, testCase := range testCases {
+			t.Run(testCase.name, func(t *testing.T) {
+				normalizedSource, normalizeErr := testCase.source.Normalize()
+				require.NoError(t, normalizeErr)
+				normalizedAudience, normalizeErr := testCase.audience.Normalize(normalizedSource)
+				require.NoError(t, normalizeErr)
+				require.NotNil(t, normalizedAudience.ProductCodes)
+
+				require.NoError(t, writer.Write(ctx, Event{
+					ID:            testCase.id,
+					AggregateType: "budget",
+					AggregateID:   "bgt_audience_contract",
+					Source:        testCase.source,
+					Audience:      testCase.audience,
+					EventType:     "commercial.budget.changed",
+					Payload:       map[string]string{"budget_ref": "bgt_audience_contract"},
+				}))
+
+				var stored OutboxEvent
+				require.NoError(t, tx.
+					Select("id", "source_product_code", "audience_scope", "audience_product_codes", "payload", "metadata", "audit_changes", "audit_meta", "retry_count", "max_retries").
+					Where("id = ?", testCase.id).
+					Take(&stored).Error)
+				require.Equal(t, normalizedAudience.Scope, stored.AudienceScope)
+				require.NotNil(t, stored.AudienceProductCodes)
+				require.Equal(t, normalizedAudience.ProductCodes, []string(stored.AudienceProductCodes))
+				if normalizedSource.Scope == EventSourceScopeProduct {
+					require.NotNil(t, stored.SourceProductCode)
+					require.Equal(t, normalizedSource.ProductCode, *stored.SourceProductCode)
+				} else {
+					require.Nil(t, stored.SourceProductCode)
+				}
+				require.Zero(t, stored.RetryCount)
+				require.Equal(t, 10, stored.MaxRetries)
+
+				var persisted struct {
+					AudienceProductCodes string `gorm:"column:audience_product_codes"`
+					AudienceJSONType     string `gorm:"column:audience_json_type"`
+					MetadataIsNull       bool   `gorm:"column:metadata_is_null"`
+					AuditChangesIsNull   bool   `gorm:"column:audit_changes_is_null"`
+					AuditMetaIsNull      bool   `gorm:"column:audit_meta_is_null"`
+				}
+				require.NoError(t, tx.Raw(`
+					SELECT
+						audience_product_codes::text AS audience_product_codes,
+						jsonb_typeof(audience_product_codes) AS audience_json_type,
+						metadata IS NULL AS metadata_is_null,
+						audit_changes IS NULL AS audit_changes_is_null,
+						audit_meta IS NULL AS audit_meta_is_null
+					FROM sys_outbox_events
+					WHERE id = ?
+				`, testCase.id).Scan(&persisted).Error)
+				expectedJSON, marshalErr := json.Marshal(normalizedAudience.ProductCodes)
+				require.NoError(t, marshalErr)
+				require.JSONEq(t, string(expectedJSON), persisted.AudienceProductCodes)
+				require.Equal(t, "array", persisted.AudienceJSONType)
+				require.True(t, persisted.MetadataIsNull)
+				require.True(t, persisted.AuditChangesIsNull)
+				require.True(t, persisted.AuditMetaIsNull)
+			})
+		}
+		return nil
+	})
+	require.NoError(t, err)
+}

package/dist/resources/templates/go-backend/internal/core/outbox/writer_test.go

@@ -0,0 +1,123 @@
+package outbox
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+func TestWriterPersistsInitialDeliveryContractWithoutDatabaseDefaults(t *testing.T) {
+	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
+	require.NoError(t, err)
+	require.NoError(t, db.Exec(`
+		CREATE TABLE sys_outbox_events (
+			id TEXT PRIMARY KEY,
+			outbox_ref TEXT NOT NULL UNIQUE,
+			aggregate_type TEXT NOT NULL,
+			aggregate_id TEXT NOT NULL,
+			aggregate_version INTEGER,
+			source_product_code TEXT,
+			audience_scope TEXT NOT NULL,
+			audience_product_codes BLOB NOT NULL,
+			event_type TEXT NOT NULL,
+			payload BLOB NOT NULL,
+			metadata BLOB,
+			audit_changes BLOB,
+			audit_meta BLOB,
+			occurred_at DATETIME NOT NULL,
+			created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+			status TEXT NOT NULL,
+			locked_at DATETIME,
+			locked_by TEXT,
+			retry_count INTEGER NOT NULL,
+			max_retries INTEGER NOT NULL,
+			next_retry_at DATETIME,
+			last_error TEXT
+		)
+	`).Error)
+
+	const eventID = "b716a64d-7c1c-4c38-9098-60b65c3e963a"
+	writer := NewWriter(db, zap.NewNop())
+	require.NoError(t, writer.Write(context.Background(), Event{
+		ID:               eventID,
+		AggregateType:    "example",
+		AggregateID:      "example_01",
+		AggregateVersion: 7,
+		Source:           ProductSource(" product_alpha "),
+		Audience:         ProductsAudience("product_beta", "product_alpha"),
+		EventType:        "example.updated",
+		Payload:          map[string]string{"reference": "example_01"},
+	}))
+
+	var stored OutboxEvent
+	require.NoError(t, db.
+		Select("id", "aggregate_version", "source_product_code", "audience_scope", "audience_product_codes", "retry_count", "max_retries").
+		Where("id = ?", eventID).
+		Take(&stored).Error)
+	require.NotNil(t, stored.AggregateVersion)
+	require.Equal(t, int64(7), *stored.AggregateVersion)
+	require.NotNil(t, stored.SourceProductCode)
+	require.Equal(t, "product_alpha", *stored.SourceProductCode)
+	require.Equal(t, AudienceScopeProducts, stored.AudienceScope)
+	require.Equal(t, []string{"product_alpha", "product_beta"}, []string(stored.AudienceProductCodes))
+	require.Zero(t, stored.RetryCount)
+	require.Equal(t, 10, stored.MaxRetries)
+}
+
+func TestWriterExplicitEventIDIsIdempotent(t *testing.T) {
+	db := openOutboxReschedulerTestDB(t)
+	writer := NewWriter(db, zap.NewNop())
+	event := Event{
+		ID:            "f86ec174-1692-51f2-9df0-8d5550eadef7",
+		AggregateType: "payment",
+		AggregateID:   "101",
+		EventType:     "payment.failed",
+		Payload:       map[string]any{"payment_id": 101, "event_id": "provider-event-1"},
+	}
+
+	require.NoError(t, writer.Write(context.Background(), event))
+	require.NoError(t, db.Model(&OutboxEvent{}).
+		Where("id = ?", event.ID).
+		Update("payload", []byte(`{ "payment_id": 101, "event_id": "provider-event-1" }`)).Error)
+	require.NoError(t, writer.Write(context.Background(), event))
+
+	var count int64
+	require.NoError(t, db.Model(&OutboxEvent{}).Where("id = ?", event.ID).Count(&count).Error)
+	require.Equal(t, int64(1), count)
+}
+
+func TestWriterExplicitEventIDRejectsDifferentEvent(t *testing.T) {
+	db := openOutboxReschedulerTestDB(t)
+	writer := NewWriter(db, zap.NewNop())
+	event := Event{
+		ID:            "c6ef4099-2e2f-59eb-a9f2-d15273147aca",
+		AggregateType: "payment",
+		AggregateID:   "101",
+		EventType:     "payment.failed",
+		Payload:       map[string]any{"payment_id": 101, "event_id": "provider-event-1"},
+	}
+	require.NoError(t, writer.Write(context.Background(), event))
+
+	event.Payload = map[string]any{"payment_id": 101, "event_id": "provider-event-2"}
+	err := writer.Write(context.Background(), event)
+	require.ErrorContains(t, err, "is already bound to a different event")
+}
+
+func TestWriterRejectsInvalidExplicitEventID(t *testing.T) {
+	db := openOutboxReschedulerTestDB(t)
+	writer := NewWriter(db, zap.NewNop())
+
+	err := writer.Write(context.Background(), Event{
+		ID:            "not-a-uuid",
+		AggregateType: "payment",
+		AggregateID:   "101",
+		EventType:     "payment.failed",
+		Payload:       map[string]any{"payment_id": 101},
+	})
+	require.ErrorContains(t, err, "parse outbox event ID")
+}

package/dist/resources/templates/go-backend/internal/core/provider.go

@@ -0,0 +1,198 @@
+package core
+
+import (
+	"github.com/redis/go-redis/v9"
+	"go.uber.org/zap"
+	"gorm.io/gorm"
+
+	"github.com/google/wire"
+
+	"{{module}}/internal/core/cache"
+	"{{module}}/internal/core/clock"
+	"{{module}}/internal/core/config"
+	"{{module}}/internal/core/database"
+	"{{module}}/internal/core/distlock"
+	"{{module}}/internal/core/eventbus"
+	"{{module}}/internal/core/geoip"
+	"{{module}}/internal/core/health"
+	"{{module}}/internal/core/httpclient"
+	corelog "{{module}}/internal/core/logger"
+	"{{module}}/internal/core/observability"
+	"{{module}}/internal/core/queue"
+	"{{module}}/internal/core/resilience"
+	"{{module}}/internal/core/schedule"
+)
+
+// ═══════════════════════════════════════════════════════════════
+// Wire ProviderSet 定义
+// ═══════════════════════════════════════════════════════════════
+
+// InfraProviderSet 核心基础设施（所有 cmd 必须引入）
+//
+// 提供以下依赖：
+//   - *config.Config — 应用配置
+//   - *config.LogConfig — 日志子配置
+//   - *config.DatabaseConfig — 数据库子配置
+//   - *config.RedisConfig — Redis 子配置
+//   - *zap.Logger — 结构化日志
+//   - *gorm.DB — 数据库连接
+//   - *cache.RedisService — Redis 缓存服务
+//   - *cache.Manager — 统一缓存管理器
+//   - *cache.WarmupRegistry — 缓存预热注册表
+//   - *resilience.CircuitBreakerService — 熔断服务
+//   - *resilience.RetryService — 重试服务
+//   - *eventbus.EventBus — 进程内事件总线
+//   - *observability.MetricsService — Prometheus 指标服务
+//   - *database.TransactionManager — 事务管理器
+var InfraProviderSet = wire.NewSet(
+	config.Load,
+	ProvideLogConfig,
+	ProvideDatabaseConfig,
+	ProvideRedisConfig,
+	corelog.New,
+	database.NewDB,
+	database.NewTransactionManager,
+	cache.NewRedisService,
+	ProvideRedisClient,
+	ProvideDistLockService,
+	ProvideCacheManagerConfig,
+	ProvideCircuitBreakerService,
+	ProvideRetryService,
+	cache.ManagerProviderSet,
+	clock.NewRuntimeClock,
+	ProvideClock,
+	eventbus.New,
+	observability.NewMetricsService,
+	observability.NewTracingService,
+	ProvideTracingConfig,
+	ProvideSentryConfig,
+	geoip.New,
+)
+
+// QueueClientProviderSet Asynq 客户端（BFF 用于入队异步任务）
+//
+// 提供以下依赖：
+//   - *queue.Client — 任务队列客户端
+//
+// 前置依赖：InfraProviderSet（需要 *config.RedisConfig 和 *zap.Logger）
+var QueueClientProviderSet = wire.NewSet(
+	queue.NewClient,
+)
+
+// QueueServerProviderSet Asynq 服务端（Worker 用于消费任务）
+//
+// 提供以下依赖：
+//   - *queue.Server — 任务队列服务端
+//
+// 前置依赖：InfraProviderSet（需要 *config.RedisConfig 和 *zap.Logger）
+var QueueServerProviderSet = wire.NewSet(
+	ProvideQueueServer,
+)
+
+// SchedulerProviderSet 定时任务调度器
+//
+// 提供以下依赖：
+//   - *schedule.Scheduler — 定时任务调度器
+//
+// 前置依赖：InfraProviderSet（需要 *zap.Logger）
+var SchedulerProviderSet = wire.NewSet(
+	schedule.New,
+)
+
+// HTTPClientProviderSet HTTP 客户端（通知模块 Webhook 处理需要）
+//
+// 提供以下依赖：
+//   - *httpclient.Client — HTTP 客户端
+//
+// 前置依赖：InfraProviderSet（需要 *zap.Logger）
+var HTTPClientProviderSet = wire.NewSet(
+	ProvideHTTPClient,
+)
+
+// ═══════════════════════════════════════════════════════════════
+// 子配置提取函数
+// ═══════════════════════════════════════════════════════════════
+
+// ProvideLogConfig 从主配置中提取日志子配置
+func ProvideLogConfig(cfg *config.Config) *config.LogConfig {
+	return &cfg.Log
+}
+
+// ProvideDatabaseConfig 从主配置中提取数据库子配置
+func ProvideDatabaseConfig(cfg *config.Config) *config.DatabaseConfig {
+	return &cfg.Database
+}
+
+// ProvideRedisConfig 从主配置中提取 Redis 子配置
+func ProvideRedisConfig(cfg *config.Config) *config.RedisConfig {
+	return &cfg.Redis
+}
+
+// ProvideTracingConfig 从主配置中提取追踪子配置
+func ProvideTracingConfig(cfg *config.Config) *config.TracingConfig {
+	return &cfg.Tracing
+}
+
+// ProvideSentryConfig 从主配置中提取 Sentry 子配置
+func ProvideSentryConfig(cfg *config.Config) *config.SentryConfig {
+	return &cfg.Sentry
+}
+
+// ProvideSentryService 创建 Sentry 服务并初始化
+func ProvideSentryService(logger *zap.Logger, cfg *config.SentryConfig) (*observability.SentryService, error) {
+	svc := observability.NewSentryService(logger, cfg)
+	if err := svc.Initialize(); err != nil {
+		return nil, err
+	}
+	return svc, nil
+}
+
+// ═══════════════════════════════════════════════════════════════
+// Wire Provider 提取与适配函数
+// ═══════════════════════════════════════════════════════════════
+
+// ProvideQueueServer 创建 Asynq 服务端（包装 variadic 参数以兼容 Wire）
+func ProvideQueueServer(cfg *config.RedisConfig, log *zap.Logger) (*queue.Server, error) {
+	return queue.NewServer(cfg, log)
+}
+
+// ProvideRedisClient 从 RedisService 提取底层 Redis 客户端
+func ProvideRedisClient(rs *cache.RedisService) *redis.Client {
+	return rs.Client()
+}
+
+// ProvideDistLockService 创建分布式锁服务
+func ProvideDistLockService(logger *zap.Logger, rdb *redis.Client) *distlock.Service {
+	return distlock.New(logger, rdb)
+}
+
+// ProvideHTTPClient 创建默认配置的 HTTP 客户端
+func ProvideHTTPClient(logger *zap.Logger) *httpclient.Client {
+	return httpclient.New(logger)
+}
+
+// ProvideCacheManagerConfig 从主配置中提取 CacheManager 配置
+func ProvideCacheManagerConfig(cfg *config.Config) *cache.ManagerConfig {
+	return cache.DefaultManagerConfig()
+}
+
+// ProvideCircuitBreakerService 创建缓存专用熔断器服务
+func ProvideCircuitBreakerService(logger *zap.Logger) *resilience.CircuitBreakerService {
+	return resilience.NewCircuitBreakerService(logger)
+}
+
+// ProvideRetryService 创建通用重试服务
+func ProvideRetryService(logger *zap.Logger) *resilience.RetryService {
+	return resilience.NewRetryService(logger)
+}
+
+// ProvideClock 将运行时时钟绑定为统一时钟接口。
+func ProvideClock(runtimeClock *clock.RuntimeClock) clock.Clock {
+	return runtimeClock
+}
+
+// ProvideHealthService 创建健康检查服务，使用默认阈值
+// Wire 不支持 variadic 参数，因此通过固定参数函数调用 health.New
+func ProvideHealthService(logger *zap.Logger, db *gorm.DB, redisClient *redis.Client) *health.Service {
+	return health.New(logger, db, redisClient)
+}

package/dist/resources/templates/go-backend/internal/core/queue/metrics_middleware.go

@@ -0,0 +1,38 @@
+package queue
+
+import (
+	"context"
+	"time"
+
+	"github.com/hibiken/asynq"
+
+	"{{module}}/internal/core/observability"
+)
+
+const defaultMetricsQueueName = "default"
+
+// MetricsMiddleware 返回 Asynq 任务处理指标中间件
+func MetricsMiddleware(metrics *observability.MetricsService) asynq.MiddlewareFunc {
+	return func(next asynq.Handler) asynq.Handler {
+		return asynq.HandlerFunc(func(ctx context.Context, task *asynq.Task) error {
+			start := time.Now()
+			err := next.ProcessTask(ctx, task)
+			duration := time.Since(start).Seconds()
+
+			status := "completed"
+			if err != nil {
+				status = "failed"
+			}
+
+			metrics.RecordQueueJob(queueNameFromContext(ctx), task.Type(), status, &duration)
+			return err
+		})
+	}
+}
+
+func queueNameFromContext(ctx context.Context) string {
+	if queueName, ok := asynq.GetQueueName(ctx); ok && queueName != "" {
+		return queueName
+	}
+	return defaultMetricsQueueName
+}

package/dist/resources/templates/go-backend/internal/core/queue/metrics_middleware_test.go

@@ -0,0 +1,12 @@
+package queue
+
+import (
+	"context"
+	"testing"
+)
+
+func TestQueueNameFromContextFallsBackToDefault(t *testing.T) {
+	if got := queueNameFromContext(context.Background()); got != defaultMetricsQueueName {
+		t.Fatalf("queueNameFromContext() = %q, want %q", got, defaultMetricsQueueName)
+	}
+}