@stackonward/cli 0.0.1 → 1.0.1

package/dist/resources/templates/go-backend/internal/core/distlock/lock_test.go

@@ -0,0 +1,106 @@
+package distlock
+
+import (
+	"context"
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/go-redsync/redsync/v4"
+	rsredis "github.com/go-redsync/redsync/v4/redis"
+	"github.com/stretchr/testify/require"
+	"go.uber.org/zap"
+)
+
+func TestAcquireMapsQuorumContentionToLockAcquisitionError(t *testing.T) {
+	service := newTestService(&testRedisPool{
+		conn: &testRedisConn{},
+	})
+	retryCount := 0
+
+	lock, err := service.Acquire(context.Background(), "scheduled-job", AcquireOptions{
+		RetryCount: &retryCount,
+	})
+
+	require.Nil(t, lock)
+	require.Error(t, err)
+	var acquisitionErr *LockAcquisitionError
+	require.ErrorAs(t, err, &acquisitionErr)
+	require.Equal(t, "scheduled-job", acquisitionErr.Resource)
+	var operationErr *LockOperationError
+	require.False(t, errors.As(err, &operationErr))
+}
+
+func TestAcquirePreservesRedisFailureAsLockOperationError(t *testing.T) {
+	redisErr := errors.New("redis unavailable")
+	service := newTestService(&testRedisPool{
+		conn: &testRedisConn{setNXErr: redisErr},
+	})
+	retryCount := 0
+
+	lock, err := service.Acquire(context.Background(), "scheduled-job", AcquireOptions{
+		RetryCount: &retryCount,
+	})
+
+	require.Nil(t, lock)
+	require.Error(t, err)
+	var operationErr *LockOperationError
+	require.ErrorAs(t, err, &operationErr)
+	require.Equal(t, "acquire", operationErr.Operation)
+	require.Equal(t, "scheduled-job", operationErr.Resource)
+	require.ErrorIs(t, err, redisErr)
+	var acquisitionErr *LockAcquisitionError
+	require.False(t, errors.As(err, &acquisitionErr))
+}
+
+func newTestService(pool rsredis.Pool) *Service {
+	return &Service{
+		logger: zap.NewNop(),
+		rs:     redsync.New(pool),
+		options: Options{
+			DefaultTTL: time.Second,
+			RetryDelay: time.Millisecond,
+			KeyPrefix:  "lock:",
+		},
+	}
+}
+
+type testRedisPool struct {
+	conn rsredis.Conn
+}
+
+func (p *testRedisPool) Get(context.Context) (rsredis.Conn, error) {
+	return p.conn, nil
+}
+
+type testRedisConn struct {
+	setNXErr error
+}
+
+func (*testRedisConn) Get(string) (string, error) {
+	return "", nil
+}
+
+func (*testRedisConn) Set(string, string) (bool, error) {
+	return true, nil
+}
+
+func (c *testRedisConn) SetNX(string, string, time.Duration) (bool, error) {
+	return false, c.setNXErr
+}
+
+func (*testRedisConn) Eval(*rsredis.Script, ...interface{}) (interface{}, error) {
+	return int64(0), nil
+}
+
+func (*testRedisConn) ScriptLoad(*rsredis.Script) error {
+	return nil
+}
+
+func (*testRedisConn) PTTL(string) (time.Duration, error) {
+	return 0, nil
+}
+
+func (*testRedisConn) Close() error {
+	return nil
+}

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

@@ -0,0 +1,189 @@
+package errors
+
+import (
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"github.com/go-playground/validator/v10"
+	"go.uber.org/zap"
+
+	"{{module}}/pkg/apierror"
+)
+
+// ═══════════════════════════════════════════════════════════════
+// 全局错误处理中间件
+// ═══════════════════════════════════════════════════════════════
+
+// GlobalErrorHandler 全局错误处理 Gin 中间件
+// 捕获 handler 中通过 c.Error() 添加的错误，统一格式化为 API 错误响应
+func GlobalErrorHandler(logger *zap.Logger, isProduction bool) gin.HandlerFunc {
+	l := logger.Named("ErrorHandler")
+
+	return func(c *gin.Context) {
+		c.Next()
+
+		// 没有错误则跳过
+		if len(c.Errors) == 0 {
+			return
+		}
+
+		// 取最后一个错误
+		err := c.Errors.Last().Err
+
+		resp, statusCode := buildErrorResponse(err, isProduction)
+
+		// 记录日志
+		logError(l, c, err, statusCode)
+
+		// 避免重复写入响应
+		if c.Writer.Written() {
+			return
+		}
+
+		c.JSON(statusCode, resp)
+	}
+}
+
+// RecoveryMiddleware Panic 恢复中间件
+func RecoveryMiddleware(logger *zap.Logger, isProduction bool) gin.HandlerFunc {
+	l := logger.Named("Recovery")
+
+	return func(c *gin.Context) {
+		defer func() {
+			if r := recover(); r != nil {
+				l.Error("panic recovered",
+					zap.String("method", c.Request.Method),
+					zap.String("url", c.Request.URL.Path),
+					zap.String("panic", fmt.Sprint(r)),
+				)
+
+				msg := "Internal server error"
+				if !isProduction {
+					switch v := r.(type) {
+					case string:
+						msg = v
+					case error:
+						msg = v.Error()
+					}
+				}
+
+				c.AbortWithStatusJSON(http.StatusInternalServerError, apierror.ErrorResponse{
+					Error: apierror.ErrorDetail{
+						Type:    apierror.TypeAPI,
+						Code:    apierror.CodeInternalError,
+						Message: msg,
+					},
+				})
+			}
+		}()
+
+		c.Next()
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 错误响应构建
+// ═══════════════════════════════════════════════════════════════
+
+func buildErrorResponse(err error, isProduction bool) (apierror.ErrorResponse, int) {
+	// 业务错误（apierror.APIError）
+	var apiErr *apierror.APIError
+	if errors.As(err, &apiErr) {
+		return apiErr.ToResponse(), apiErr.Status
+	}
+
+	// validator 校验错误
+	var validationErrors validator.ValidationErrors
+	if errors.As(err, &validationErrors) {
+		fieldErrors := make([]apierror.FieldError, 0, len(validationErrors))
+		for _, fe := range validationErrors {
+			fieldErrors = append(fieldErrors, apierror.FieldError{
+				Field:   toSnakeCase(fe.Field()),
+				Message: formatValidationMessage(fe),
+			})
+		}
+		resp := apierror.ValidationFailed(fieldErrors)
+		return resp.ToResponse(), resp.Status
+	}
+
+	// 未知错误
+	msg := "Internal server error"
+	if !isProduction {
+		msg = err.Error()
+	}
+
+	return apierror.ErrorResponse{
+		Error: apierror.ErrorDetail{
+			Type:    apierror.TypeAPI,
+			Code:    apierror.CodeInternalError,
+			Message: msg,
+		},
+	}, http.StatusInternalServerError
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 日志记录
+// ═══════════════════════════════════════════════════════════════
+
+func logError(logger *zap.Logger, c *gin.Context, err error, statusCode int) {
+	fields := []zap.Field{
+		zap.String("method", c.Request.Method),
+		zap.String("url", c.Request.URL.Path),
+		zap.Int("statusCode", statusCode),
+		zap.String("clientIP", c.ClientIP()),
+		zap.String("userAgent", c.Request.UserAgent()),
+	}
+
+	if statusCode >= 500 {
+		logger.Error("server error", append(fields, zap.Error(err))...)
+	} else if statusCode >= 400 {
+		logger.Warn("client error", append(fields, zap.Error(err))...)
+	}
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 辅助函数
+// ═══════════════════════════════════════════════════════════════
+
+// toSnakeCase 将 PascalCase 转为 snake_case
+func toSnakeCase(s string) string {
+	var result strings.Builder
+	for i, r := range s {
+		if i > 0 && r >= 'A' && r <= 'Z' {
+			result.WriteByte('_')
+		}
+		result.WriteRune(r)
+	}
+	return strings.ToLower(result.String())
+}
+
+// formatValidationMessage 格式化校验错误消息
+func formatValidationMessage(fe validator.FieldError) string {
+	switch fe.Tag() {
+	case "required":
+		return "is required"
+	case "email":
+		return "must be a valid email address"
+	case "min":
+		return "must be at least " + fe.Param()
+	case "max":
+		return "must be at most " + fe.Param()
+	case "len":
+		return "must be exactly " + fe.Param() + " characters"
+	case "gte":
+		return "must be greater than or equal to " + fe.Param()
+	case "lte":
+		return "must be less than or equal to " + fe.Param()
+	case "oneof":
+		return "must be one of: " + fe.Param()
+	case "uuid":
+		return "must be a valid UUID"
+	case "url":
+		return "must be a valid URL"
+	default:
+		return "failed validation: " + fe.Tag()
+	}
+}