@stackonward/cli 1.4.0 → 1.5.1

package/dist/resources/templates/go-backend/internal/core/integrationevent/persistence_postgres_test.go

@@ -0,0 +1,178 @@
+package integrationevent
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/stdlib"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+
+	"{{module}}/internal/core/database"
+)
+
+func TestReceiverServiceSerializesAggregateVersionsOnPostgres(t *testing.T) {
+	db := openIntegrationEventPostgres(t)
+	firstStarted := make(chan struct{})
+	releaseFirst := make(chan struct{})
+	secondHandled := make(chan struct{})
+	registry := NewHandlerRegistry()
+	if err := registry.Register(HandlerRegistration{
+		SourceSystem: "source-a", EventType: "resource.changed", SchemaVersion: "1.0.0",
+		Handler: HandlerFunc(func(_ context.Context, envelope Envelope) error {
+			switch envelope.AggregateVersion {
+			case 1:
+				close(firstStarted)
+				<-releaseFirst
+			case 2:
+				close(secondHandled)
+			}
+			return nil
+		}),
+	}); err != nil {
+		t.Fatalf("Register() error = %v", err)
+	}
+	service, err := NewReceiverService(
+		NewRepository(db), database.NewTransactionManager(db), registry,
+		ReceiverConfig{SubscriberCode: "subscriber-a"},
+	)
+	if err != nil {
+		t.Fatalf("NewReceiverService() error = %v", err)
+	}
+
+	firstDone := make(chan error, 1)
+	go func() {
+		_, receiveErr := service.Receive(context.Background(), fakeEnvelope("event-1", 1, []byte(`{"value":1}`)))
+		firstDone <- receiveErr
+	}()
+	select {
+	case <-firstStarted:
+	case <-time.After(5 * time.Second):
+		close(releaseFirst)
+		t.Fatal("version 1 handler did not start")
+	}
+
+	secondDone := make(chan error, 1)
+	go func() {
+		_, receiveErr := service.Receive(context.Background(), fakeEnvelope("event-2", 2, []byte(`{"value":2}`)))
+		secondDone <- receiveErr
+	}()
+	select {
+	case <-secondHandled:
+		close(releaseFirst)
+		t.Fatal("version 2 handler ran before version 1 committed")
+	case <-time.After(100 * time.Millisecond):
+	}
+	close(releaseFirst)
+
+	for name, done := range map[string]<-chan error{"version 1": firstDone, "version 2": secondDone} {
+		select {
+		case receiveErr := <-done:
+			if receiveErr != nil {
+				t.Fatalf("%s Receive() error = %v", name, receiveErr)
+			}
+		case <-time.After(5 * time.Second):
+			t.Fatalf("%s Receive() did not complete", name)
+		}
+	}
+
+	var checkpoint AggregateCheckpoint
+	if err := db.Take(&checkpoint).Error; err != nil {
+		t.Fatalf("load checkpoint: %v", err)
+	}
+	if checkpoint.LastAggregateVersion != 2 || checkpoint.RevisionNo != 2 {
+		t.Fatalf("checkpoint = %#v, want version/revision 2", checkpoint)
+	}
+}
+
+func openIntegrationEventPostgres(t *testing.T) *gorm.DB {
+	t.Helper()
+	baseDSN := strings.TrimSpace(os.Getenv("ONEX_TEST_POSTGRES_DSN"))
+	if baseDSN == "" {
+		t.Skip("ONEX_TEST_POSTGRES_DSN is not set")
+	}
+	adminConfig, err := pgx.ParseConfig(baseDSN)
+	if err != nil {
+		t.Fatalf("parse PostgreSQL test DSN: %v", err)
+	}
+	adminDB := stdlib.OpenDB(*adminConfig)
+	if err := adminDB.PingContext(context.Background()); err != nil {
+		_ = adminDB.Close()
+		t.Fatalf("ping PostgreSQL admin database: %v", err)
+	}
+	databaseName := fmt.Sprintf("integration_event_%d", time.Now().UnixNano())
+	if _, err := adminDB.ExecContext(context.Background(), `CREATE DATABASE "`+databaseName+`"`); err != nil {
+		_ = adminDB.Close()
+		t.Fatalf("create PostgreSQL test database: %v", err)
+	}
+
+	testConfig := adminConfig.Copy()
+	testConfig.Database = databaseName
+	testDB := stdlib.OpenDB(*testConfig)
+	if err := testDB.PingContext(context.Background()); err != nil {
+		_ = testDB.Close()
+		_ = adminDB.Close()
+		t.Fatalf("ping PostgreSQL test database: %v", err)
+	}
+	db, err := gorm.Open(postgres.New(postgres.Config{Conn: testDB}), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
+	if err != nil {
+		_ = testDB.Close()
+		_ = adminDB.Close()
+		t.Fatalf("open PostgreSQL test database: %v", err)
+	}
+	t.Cleanup(func() {
+		if err := testDB.Close(); err != nil {
+			t.Errorf("close PostgreSQL test database: %v", err)
+		}
+		if _, err := adminDB.ExecContext(
+			context.Background(),
+			"SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid <> pg_backend_pid()",
+			databaseName,
+		); err != nil {
+			t.Errorf("terminate PostgreSQL test sessions: %v", err)
+		}
+		if _, err := adminDB.ExecContext(context.Background(), `DROP DATABASE IF EXISTS "`+databaseName+`"`); err != nil {
+			t.Errorf("drop PostgreSQL test database: %v", err)
+		}
+		if err := adminDB.Close(); err != nil {
+			t.Errorf("close PostgreSQL admin database: %v", err)
+		}
+	})
+
+	statements := []string{
+		`CREATE TABLE sys_integration_event_inbox (
+			id BIGSERIAL PRIMARY KEY, source_system VARCHAR(191) NOT NULL, event_id VARCHAR(191) NOT NULL,
+			event_type VARCHAR(191) NOT NULL, schema_version VARCHAR(32) NOT NULL, product_code VARCHAR(50) NOT NULL,
+			aggregate_type VARCHAR(128) NOT NULL, aggregate_ref VARCHAR(191) NOT NULL, aggregate_version BIGINT NOT NULL,
+			payload_hash CHAR(64) NOT NULL, event_payload JSONB NOT NULL, received_at TIMESTAMPTZ(3) NOT NULL,
+			created_at TIMESTAMPTZ(3) NOT NULL, UNIQUE(source_system, event_id)
+		)`,
+		`CREATE TABLE sys_integration_event_receipts (
+			id BIGSERIAL PRIMARY KEY, source_system VARCHAR(191) NOT NULL, subscriber_code VARCHAR(64) NOT NULL,
+			event_id VARCHAR(191) NOT NULL, status VARCHAR(20) NOT NULL, receipt_status VARCHAR(20), error_code VARCHAR(120),
+			processing_started_at TIMESTAMPTZ(3) NOT NULL, processed_at TIMESTAMPTZ(3),
+			created_at TIMESTAMPTZ(3) NOT NULL, updated_at TIMESTAMPTZ(3) NOT NULL,
+			UNIQUE(source_system, subscriber_code, event_id)
+		)`,
+		`CREATE TABLE sys_integration_aggregate_checkpoints (
+			id BIGSERIAL PRIMARY KEY, source_system VARCHAR(191) NOT NULL, subscriber_code VARCHAR(64) NOT NULL,
+			aggregate_type VARCHAR(128) NOT NULL, aggregate_ref VARCHAR(191) NOT NULL,
+			last_aggregate_version BIGINT NOT NULL, last_event_id VARCHAR(191) NOT NULL,
+			last_payload_hash CHAR(64) NOT NULL, revision_no BIGINT NOT NULL,
+			created_at TIMESTAMPTZ(3) NOT NULL, updated_at TIMESTAMPTZ(3) NOT NULL,
+			UNIQUE(source_system, subscriber_code, aggregate_type, aggregate_ref)
+		)`,
+	}
+	for _, statement := range statements {
+		if err := db.Exec(statement).Error; err != nil {
+			t.Fatalf("create PostgreSQL integration event schema: %v", err)
+		}
+	}
+	return db
+}

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

@@ -0,0 +1,168 @@
+package integrationevent
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+
+	"{{module}}/internal/core/database"
+)
+
+func TestRepositoryRequiresTransactionForInboxMutation(t *testing.T) {
+	db := openSQLiteIntegrationEventDB(t)
+	repo := NewRepository(db)
+	_, _, err := repo.CreateOrLoadInbox(context.Background(), &InboxRecord{})
+	if err == nil || !strings.Contains(err.Error(), "transaction context is required") {
+		t.Fatalf("CreateOrLoadInbox() error = %v, want transaction requirement", err)
+	}
+}
+
+func TestReceiverServiceSQLiteCommitsHandlerAndCoreStateTogether(t *testing.T) {
+	db := openSQLiteIntegrationEventDB(t)
+	service := newSQLiteReceiverService(t, db, func(ctx context.Context, envelope Envelope) error {
+		return database.GetDB(ctx, db).Exec(
+			"INSERT INTO integration_event_test_projections (event_id, aggregate_version) VALUES (?, ?)",
+			envelope.EventID,
+			envelope.AggregateVersion,
+		).Error
+	})
+
+	result, err := service.Receive(context.Background(), fakeEnvelope("event-1", 1, []byte(`{"value":1}`)))
+	if err != nil {
+		t.Fatalf("Receive() error = %v", err)
+	}
+	if result.Outcome != ReceiptOutcomeProcessed {
+		t.Fatalf("Receive() outcome = %q, want processed", result.Outcome)
+	}
+	assertSQLiteCount(t, db, "sys_integration_event_inbox", 1)
+	assertSQLiteCount(t, db, "sys_integration_event_receipts", 1)
+	assertSQLiteCount(t, db, "sys_integration_aggregate_checkpoints", 1)
+	assertSQLiteCount(t, db, "integration_event_test_projections", 1)
+
+	duplicate, err := service.Receive(context.Background(), fakeEnvelope("event-1", 1, []byte(`{"value":1}`)))
+	if err != nil {
+		t.Fatalf("Receive(duplicate) error = %v", err)
+	}
+	if duplicate.Outcome != ReceiptOutcomeDuplicate {
+		t.Fatalf("Receive(duplicate) outcome = %q, want duplicate", duplicate.Outcome)
+	}
+	assertSQLiteCount(t, db, "integration_event_test_projections", 1)
+}
+
+func TestReceiverServiceSQLiteRollsBackHandlerFailure(t *testing.T) {
+	db := openSQLiteIntegrationEventDB(t)
+	handlerErr := errors.New("projection failed")
+	service := newSQLiteReceiverService(t, db, func(ctx context.Context, envelope Envelope) error {
+		if err := database.GetDB(ctx, db).Exec(
+			"INSERT INTO integration_event_test_projections (event_id, aggregate_version) VALUES (?, ?)",
+			envelope.EventID,
+			envelope.AggregateVersion,
+		).Error; err != nil {
+			return err
+		}
+		return handlerErr
+	})
+
+	_, err := service.Receive(context.Background(), fakeEnvelope("event-1", 1, []byte(`{"value":1}`)))
+	if !errors.Is(err, handlerErr) {
+		t.Fatalf("Receive() error = %v, want handler error", err)
+	}
+	assertSQLiteCount(t, db, "sys_integration_event_inbox", 0)
+	assertSQLiteCount(t, db, "sys_integration_event_receipts", 0)
+	assertSQLiteCount(t, db, "sys_integration_aggregate_checkpoints", 0)
+	assertSQLiteCount(t, db, "integration_event_test_projections", 0)
+}
+
+func TestReceiverServiceSQLiteRollsBackVersionGap(t *testing.T) {
+	db := openSQLiteIntegrationEventDB(t)
+	service := newSQLiteReceiverService(t, db, func(context.Context, Envelope) error {
+		t.Fatal("handler must not run for a version gap")
+		return nil
+	})
+
+	_, err := service.Receive(context.Background(), fakeEnvelope("event-2", 2, []byte(`{"value":2}`)))
+	var gap *VersionGapError
+	if !errors.As(err, &gap) {
+		t.Fatalf("Receive() error = %v, want VersionGapError", err)
+	}
+	assertSQLiteCount(t, db, "sys_integration_event_inbox", 0)
+	assertSQLiteCount(t, db, "sys_integration_event_receipts", 0)
+	assertSQLiteCount(t, db, "sys_integration_aggregate_checkpoints", 0)
+}
+
+func newSQLiteReceiverService(t *testing.T, db *gorm.DB, handler HandlerFunc) *ReceiverService {
+	t.Helper()
+	registry := NewHandlerRegistry()
+	if err := registry.Register(HandlerRegistration{
+		SourceSystem: "source-a", EventType: "resource.changed", SchemaVersion: "1.0.0", Handler: handler,
+	}); err != nil {
+		t.Fatalf("Register() error = %v", err)
+	}
+	service, err := NewReceiverService(
+		NewRepository(db),
+		database.NewTransactionManager(db),
+		registry,
+		ReceiverConfig{SubscriberCode: "subscriber-a"},
+	)
+	if err != nil {
+		t.Fatalf("NewReceiverService() error = %v", err)
+	}
+	return service
+}
+
+func openSQLiteIntegrationEventDB(t *testing.T) *gorm.DB {
+	t.Helper()
+	name := strings.NewReplacer("/", "_", " ", "_").Replace(t.Name())
+	db, err := gorm.Open(sqlite.Open(fmt.Sprintf("file:%s?mode=memory&cache=shared&_loc=auto", name)), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
+	if err != nil {
+		t.Fatalf("open SQLite: %v", err)
+	}
+	statements := []string{
+		`CREATE TABLE sys_integration_event_inbox (
+			id INTEGER PRIMARY KEY AUTOINCREMENT, source_system TEXT NOT NULL, event_id TEXT NOT NULL,
+			event_type TEXT NOT NULL, schema_version TEXT NOT NULL, product_code TEXT NOT NULL,
+			aggregate_type TEXT NOT NULL, aggregate_ref TEXT NOT NULL, aggregate_version INTEGER NOT NULL,
+			payload_hash TEXT NOT NULL, event_payload TEXT NOT NULL, received_at DATETIME NOT NULL,
+			created_at DATETIME NOT NULL, UNIQUE(source_system, event_id)
+		)`,
+		`CREATE TABLE sys_integration_event_receipts (
+			id INTEGER PRIMARY KEY AUTOINCREMENT, source_system TEXT NOT NULL, subscriber_code TEXT NOT NULL,
+			event_id TEXT NOT NULL, status TEXT NOT NULL, receipt_status TEXT, error_code TEXT,
+			processing_started_at DATETIME NOT NULL, processed_at DATETIME, created_at DATETIME NOT NULL,
+			updated_at DATETIME NOT NULL, UNIQUE(source_system, subscriber_code, event_id)
+		)`,
+		`CREATE TABLE sys_integration_aggregate_checkpoints (
+			id INTEGER PRIMARY KEY AUTOINCREMENT, source_system TEXT NOT NULL, subscriber_code TEXT NOT NULL,
+			aggregate_type TEXT NOT NULL, aggregate_ref TEXT NOT NULL, last_aggregate_version INTEGER NOT NULL,
+			last_event_id TEXT NOT NULL, last_payload_hash TEXT NOT NULL, revision_no INTEGER NOT NULL,
+			created_at DATETIME NOT NULL, updated_at DATETIME NOT NULL,
+			UNIQUE(source_system, subscriber_code, aggregate_type, aggregate_ref)
+		)`,
+		`CREATE TABLE integration_event_test_projections (
+			event_id TEXT PRIMARY KEY, aggregate_version INTEGER NOT NULL
+		)`,
+	}
+	for _, statement := range statements {
+		if err := db.Exec(statement).Error; err != nil {
+			t.Fatalf("create SQLite integration event schema: %v", err)
+		}
+	}
+	return db
+}
+
+func assertSQLiteCount(t *testing.T, db *gorm.DB, table string, want int64) {
+	t.Helper()
+	var count int64
+	if err := db.Table(table).Count(&count).Error; err != nil {
+		t.Fatalf("count %s: %v", table, err)
+	}
+	if count != want {
+		t.Fatalf("%s count = %d, want %d", table, count, want)
+	}
+}

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

@@ -0,0 +1,16 @@
+package integrationevent
+
+import (
+	"github.com/google/wire"
+
+	"{{module}}/internal/core/database"
+)
+
+// ProviderSet 提供入站事件仓储、处理器注册表与接收服务。
+// ReceiverConfig 由具体消费者提供，处理器由消费者在启动阶段精确注册。
+var ProviderSet = wire.NewSet(
+	NewRepository,
+	NewHandlerRegistry,
+	NewReceiverService,
+	wire.Bind(new(TransactionManager), new(*database.TransactionManager)),
+)

package/dist/resources/templates/go-backend/internal/core/integrationevent/registry.go

@@ -0,0 +1,69 @@
+package integrationevent
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+)
+
+type handlerKey struct {
+	sourceSystem  string
+	eventType     string
+	schemaVersion string
+}
+
+// HandlerRegistry 保存消费者启动时注册的精确事件版本处理器。
+type HandlerRegistry struct {
+	mu       sync.RWMutex
+	handlers map[handlerKey]Handler
+}
+
+// NewHandlerRegistry 创建空的处理器注册表。
+func NewHandlerRegistry() *HandlerRegistry {
+	return &HandlerRegistry{handlers: make(map[handlerKey]Handler)}
+}
+
+// Register 注册精确 source/type/schema 处理器，重复注册会失败。
+func (r *HandlerRegistry) Register(registration HandlerRegistration) error {
+	key, err := normalizeHandlerKey(registration.SourceSystem, registration.EventType, registration.SchemaVersion)
+	if err != nil {
+		return err
+	}
+	if registration.Handler == nil {
+		return fmt.Errorf("integration event handler is required")
+	}
+
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	if _, exists := r.handlers[key]; exists {
+		return fmt.Errorf("integration event handler is already registered for %s/%s/%s", key.sourceSystem, key.eventType, key.schemaVersion)
+	}
+	r.handlers[key] = registration.Handler
+	return nil
+}
+
+func (r *HandlerRegistry) resolve(sourceSystem, eventType, schemaVersion string) (Handler, bool) {
+	if r == nil {
+		return nil, false
+	}
+	key, err := normalizeHandlerKey(sourceSystem, eventType, schemaVersion)
+	if err != nil {
+		return nil, false
+	}
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	handler, exists := r.handlers[key]
+	return handler, exists
+}
+
+func normalizeHandlerKey(sourceSystem, eventType, schemaVersion string) (handlerKey, error) {
+	key := handlerKey{
+		sourceSystem:  strings.TrimSpace(sourceSystem),
+		eventType:     strings.TrimSpace(eventType),
+		schemaVersion: strings.TrimSpace(schemaVersion),
+	}
+	if key.sourceSystem == "" || key.eventType == "" || key.schemaVersion == "" {
+		return handlerKey{}, fmt.Errorf("integration event handler key is incomplete")
+	}
+	return key, nil
+}

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

@@ -0,0 +1,17 @@
+package integrationevent
+
+import (
+	"context"
+	"time"
+)
+
+// Repository 定义入站事件身份、订阅者回执与聚合水位的事务仓储。
+type Repository interface {
+	CreateOrLoadInbox(ctx context.Context, record *InboxRecord) (*InboxRecord, bool, error)
+	CreateOrLockReceipt(ctx context.Context, record *ReceiptRecord) (*ReceiptRecord, bool, error)
+	LockAggregateScope(ctx context.Context, sourceSystem, subscriberCode, aggregateType, aggregateRef string) error
+	FindCheckpointForUpdate(ctx context.Context, sourceSystem, subscriberCode, aggregateType, aggregateRef string) (*AggregateCheckpoint, error)
+	CreateCheckpoint(ctx context.Context, checkpoint *AggregateCheckpoint) error
+	AdvanceCheckpoint(ctx context.Context, checkpoint *AggregateCheckpoint, expectedRevision int64) error
+	MarkReceiptProcessed(ctx context.Context, id int64, outcome ReceiptOutcome, processedAt time.Time) error
+}