@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/common/ruleexpression/fuzz_test.go

@@ -0,0 +1,116 @@
+package ruleexpression
+
+import (
+	"bytes"
+	"math"
+	"testing"
+)
+
+func FuzzDecode(f *testing.F) {
+	f.Add([]byte(`{"schema_version":1,"root":{"kind":"predicate","subject":"capability","key":"billing","operator":"active"}}`))
+	f.Add([]byte(`{"root":{"children":[{"operator":"eq","value":4.50,"subject":"attribute","key":"score","kind":"predicate"}],"kind":"all"},"schema_version":1}`))
+	f.Add([]byte(`{"schema_version":1,"schema_version":1,"root":null}`))
+	f.Add([]byte(`{"schema_version":1,"root":{"kind":"not","child":{"kind":"predicate","subject":"attribute","key":"label","operator":"eq","value":"\ud800"}}}`))
+
+	f.Fuzz(func(t *testing.T, raw []byte) {
+		expression, err := Decode(raw)
+		if err != nil {
+			return
+		}
+		canonical, err := CanonicalJSON(expression)
+		if err != nil {
+			t.Fatalf("CanonicalJSON() after Decode() error = %v", err)
+		}
+		if len(canonical) > MaxJSONBytes {
+			t.Fatalf("canonical length = %d, want <= %d", len(canonical), MaxJSONBytes)
+		}
+		roundTrip, err := Decode(canonical)
+		if err != nil {
+			t.Fatalf("Decode(canonical) error = %v; canonical = %s", err, canonical)
+		}
+		second, err := CanonicalJSON(roundTrip)
+		if err != nil {
+			t.Fatalf("CanonicalJSON(round trip) error = %v", err)
+		}
+		if !bytes.Equal(canonical, second) {
+			t.Fatalf("canonicalization is not idempotent: first=%s second=%s", canonical, second)
+		}
+		firstHash, err := CanonicalHash(expression)
+		if err != nil {
+			t.Fatalf("CanonicalHash() error = %v", err)
+		}
+		secondHash, err := CanonicalHash(roundTrip)
+		if err != nil {
+			t.Fatalf("CanonicalHash(round trip) error = %v", err)
+		}
+		if firstHash != secondHash {
+			t.Fatalf("hash is not stable: first=%s second=%s", firstHash, secondHash)
+		}
+	})
+}
+
+func FuzzCanonicalization(f *testing.F) {
+	f.Add("physical_goods", 4.5, uint8(0))
+	f.Add("€$\x0f\n", math.Copysign(0, -1), uint8(1))
+	f.Add("", 1e30, uint8(2))
+	f.Add("invalid\xff", 0.0, uint8(3))
+
+	f.Fuzz(func(t *testing.T, text string, number float64, selector uint8) {
+		predicate := &PredicateNode{Subject: SubjectAttribute, Key: "value", Operator: OperatorEqual}
+		switch selector % 4 {
+		case 0:
+			predicate.Value = &StringValue{Value: text}
+		case 1:
+			predicate.Value = &NumberValue{Value: number}
+		case 2:
+			predicate.Value = &BooleanValue{Value: selector%2 == 0}
+		case 3:
+			predicate.Operator = OperatorIn
+			predicate.Value = &StringArrayValue{Values: []string{text, "fixed"}}
+		}
+		expression := expressionWithRoot(&AnyNode{Children: []Node{predicate, &NotNode{Child: resultPredicate("fallback")}}})
+		canonical, err := CanonicalJSON(expression)
+		if err != nil {
+			return
+		}
+		decoded, err := Decode(canonical)
+		if err != nil {
+			t.Fatalf("Decode(canonical) error = %v; canonical = %s", err, canonical)
+		}
+		roundTrip, err := CanonicalJSON(decoded)
+		if err != nil {
+			t.Fatalf("CanonicalJSON(round trip) error = %v", err)
+		}
+		if !bytes.Equal(canonical, roundTrip) {
+			t.Fatalf("canonicalization is not idempotent: first=%s second=%s", canonical, roundTrip)
+		}
+	})
+}
+
+func FuzzEvaluate(f *testing.F) {
+	f.Add([]byte(`{"schema_version":1,"root":{"kind":"predicate","subject":"attribute","key":"enabled","operator":"exists"}}`))
+	f.Add([]byte(`{"schema_version":1,"root":{"kind":"all","children":[{"kind":"predicate","subject":"capability","key":"billing","operator":"active"},{"kind":"not","child":{"kind":"predicate","subject":"attribute","key":"disabled","operator":"exists"}}]}}`))
+
+	f.Fuzz(func(t *testing.T, raw []byte) {
+		expression, err := Decode(raw)
+		if err != nil {
+			return
+		}
+		result, err := Evaluate(expression, func(predicate *PredicateNode) (Result, error) {
+			switch len(predicate.Key) % 3 {
+			case 0:
+				return ResultTrue, nil
+			case 1:
+				return ResultFalse, nil
+			default:
+				return ResultIndeterminate, nil
+			}
+		})
+		if err != nil {
+			t.Fatalf("Evaluate() after Decode() error = %v", err)
+		}
+		if !result.IsValid() {
+			t.Fatalf("Evaluate() result = %q", result)
+		}
+	})
+}

package/dist/resources/templates/go-backend/internal/common/ruleexpression/limits.go

@@ -0,0 +1,331 @@
+package ruleexpression
+
+import (
+	"fmt"
+	"math"
+	"unicode/utf8"
+)
+
+const (
+	// MaxJSONBytes 限制完整表达式 JSON 的字节数。
+	MaxJSONBytes = 16 * 1024
+	// MaxDepth 限制根节点计为第一层时的 AST 深度。
+	MaxDepth = 8
+	// MaxNodes 限制单个表达式的节点总数。
+	MaxNodes = 64
+	// MaxChildren 限制 all 和 any 的直接子节点数。
+	MaxChildren = 16
+	// MaxStringLength 按 Unicode code point 限制字符串长度。
+	MaxStringLength = 128
+	// MaxStringArrayItems 限制字符串数组元素数。
+	MaxStringArrayItems = 32
+	// MaxFreshWithinSeconds 限制 freshness 时间窗上界。
+	MaxFreshWithinSeconds = 86400
+)
+
+const maxCatalogCodeLength = 80
+
+type validationState struct {
+	nodes int
+	stack map[Node]struct{}
+}
+
+func validateExpression(expression ExpressionV1) error {
+	if expression.SchemaVersion != SchemaVersionV1 {
+		return newError(
+			ErrorCodeUnsupportedSchemaVersion,
+			"$.schema_version",
+			fmt.Sprintf("schema_version must be %d", SchemaVersionV1),
+		)
+	}
+	state := validationState{stack: make(map[Node]struct{})}
+	return validateNode(expression.Root, "$.root", 1, &state)
+}
+
+func validateNode(node Node, path string, depth int, state *validationState) error {
+	if node == nil {
+		return newError(ErrorCodeInvalidNode, path, "node must not be null")
+	}
+	if depth > MaxDepth {
+		return newError(ErrorCodeLimitExceeded, path, fmt.Sprintf("node depth must not exceed %d", MaxDepth))
+	}
+	state.nodes++
+	if state.nodes > MaxNodes {
+		return newError(ErrorCodeLimitExceeded, path, fmt.Sprintf("node count must not exceed %d", MaxNodes))
+	}
+	if err := validateNodeType(node, path); err != nil {
+		return err
+	}
+	if _, exists := state.stack[node]; exists {
+		return newError(ErrorCodeInvalidNode, path, "node graph must not contain cycles")
+	}
+	state.stack[node] = struct{}{}
+	defer delete(state.stack, node)
+
+	switch current := node.(type) {
+	case *AllNode:
+		return validateChildren(current.Children, path+".children", depth, state)
+	case *AnyNode:
+		return validateChildren(current.Children, path+".children", depth, state)
+	case *NotNode:
+		return validateNode(current.Child, path+".child", depth+1, state)
+	case *PredicateNode:
+		return validatePredicate(current, path)
+	default:
+		return newError(ErrorCodeInvalidNode, path, "node kind is not supported")
+	}
+}
+
+func validateNodeType(node Node, path string) error {
+	switch current := node.(type) {
+	case *AllNode:
+		if current == nil {
+			return newError(ErrorCodeInvalidNode, path, "all node must not be null")
+		}
+	case *AnyNode:
+		if current == nil {
+			return newError(ErrorCodeInvalidNode, path, "any node must not be null")
+		}
+	case *NotNode:
+		if current == nil {
+			return newError(ErrorCodeInvalidNode, path, "not node must not be null")
+		}
+	case *PredicateNode:
+		if current == nil {
+			return newError(ErrorCodeInvalidNode, path, "predicate node must not be null")
+		}
+	default:
+		return newError(ErrorCodeInvalidNode, path, "node kind is not supported")
+	}
+	return nil
+}
+
+func validateChildren(children []Node, path string, depth int, state *validationState) error {
+	if len(children) == 0 {
+		return newError(ErrorCodeInvalidNode, path, "children must not be empty")
+	}
+	if len(children) > MaxChildren {
+		return newError(ErrorCodeLimitExceeded, path, fmt.Sprintf("children count must not exceed %d", MaxChildren))
+	}
+	for i := range children {
+		if err := validateNode(children[i], fmt.Sprintf("%s[%d]", path, i), depth+1, state); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func validatePredicate(predicate *PredicateNode, path string) error {
+	keyShape, keyMaxLength, ok := subjectKeyConstraint(predicate.Subject)
+	if !ok {
+		return newError(ErrorCodeInvalidPredicate, path+".subject", "subject is not supported")
+	}
+	if err := validatePredicateKey(predicate.Subject, keyShape, keyMaxLength, predicate.Key, path+".key"); err != nil {
+		return err
+	}
+	valueShape, valueTypes, ok := operatorConstraint(predicate.Subject, predicate.Operator)
+	if !ok {
+		return newError(ErrorCodeInvalidPredicate, path+".operator", fmt.Sprintf("operator is not supported for %s subject", predicate.Subject))
+	}
+	return validatePredicateValue(predicate.Value, valueShape, valueTypes, path+".value")
+}
+
+func subjectKeyConstraint(subject Subject) (KeyShape, int, bool) {
+	switch subject {
+	case SubjectProduct:
+		return KeyShapeFixed, MaxStringLength, true
+	case SubjectAttribute, SubjectCapability:
+		return KeyShapeSnakeCode, maxCatalogCodeLength, true
+	case SubjectInsightsMetric, SubjectProductDataset:
+		return KeyShapeNamespacedCode, MaxStringLength, true
+	default:
+		return "", 0, false
+	}
+}
+
+func validatePredicateKey(subject Subject, keyShape KeyShape, keyMaxLength int, key string, path string) error {
+	if err := validateString(key, path); err != nil {
+		return err
+	}
+	switch keyShape {
+	case KeyShapeFixed:
+		if subject == SubjectProduct && (key == "code" || key == "lifecycle_status") {
+			return nil
+		}
+		return newError(ErrorCodeInvalidPredicate, path, fmt.Sprintf("key is not supported for %s subject", subject))
+	case KeyShapeSnakeCode:
+		if !isSnakeCode(key, keyMaxLength) {
+			return newError(ErrorCodeInvalidPredicate, path, "key must be a lowercase snake_case code")
+		}
+	case KeyShapeNamespacedCode:
+		if !isNamespacedCode(key) {
+			return newError(ErrorCodeInvalidPredicate, path, "key must be a lowercase namespaced dot code")
+		}
+	default:
+		return newError(ErrorCodeInvalidPredicate, path, "key shape is not supported")
+	}
+	return nil
+}
+
+func validatePredicateValue(value Value, valueShape ValueShape, allowed valueTypeMask, path string) error {
+	switch valueShape {
+	case ValueShapeNone:
+		return requireNoValue(value, path)
+	case ValueShapeComparable:
+		return validateComparableValue(value, allowed, path)
+	case ValueShapeStringArray:
+		items, ok := value.(*StringArrayValue)
+		if !ok || items == nil {
+			return newError(ErrorCodeInvalidPredicate, path, "operator requires a string array value")
+		}
+		return validateStringArray(items.Values, path)
+	case ValueShapePositiveInteger:
+		return validatePositiveInteger(value, path)
+	default:
+		return newError(ErrorCodeInvalidPredicate, path, "operator value shape is not supported")
+	}
+}
+
+func validatePositiveInteger(value Value, path string) error {
+	number, ok := value.(*NumberValue)
+	if !ok || number == nil {
+		return newError(ErrorCodeInvalidPredicate, path, "operator requires a number value")
+	}
+	if math.IsNaN(number.Value) || math.IsInf(number.Value, 0) {
+		return newError(ErrorCodeInvalidNumber, path, "number must be finite")
+	}
+	if math.Trunc(number.Value) != number.Value || number.Value < 1 || number.Value > MaxFreshWithinSeconds {
+		return newError(ErrorCodeInvalidPredicate, path, fmt.Sprintf("value must be an integer from 1 to %d", MaxFreshWithinSeconds))
+	}
+	return nil
+}
+
+func requireNoValue(value Value, path string) error {
+	if value != nil {
+		return newError(ErrorCodeInvalidPredicate, path, "operator does not accept a value")
+	}
+	return nil
+}
+
+func validateComparableValue(value Value, allowed valueTypeMask, path string) error {
+	valueType, ok := requirementValueType(value)
+	if !ok || allowed&valueTypeMaskFor(valueType) == 0 {
+		return newError(ErrorCodeInvalidPredicate, path, "operator requires a supported scalar value")
+	}
+	switch current := value.(type) {
+	case *BooleanValue:
+		return nil
+	case *NumberValue:
+		if math.IsNaN(current.Value) || math.IsInf(current.Value, 0) {
+			return newError(ErrorCodeInvalidNumber, path, "number must be finite")
+		}
+		return nil
+	case *StringValue:
+		return validateString(current.Value, path)
+	case *StringArrayValue:
+		return validateStringArray(current.Values, path)
+	default:
+		return newError(ErrorCodeInvalidPredicate, path, "operator requires a supported scalar value")
+	}
+}
+
+func requirementValueType(value Value) (ValueType, bool) {
+	switch current := value.(type) {
+	case *BooleanValue:
+		return ValueTypeBoolean, current != nil
+	case *NumberValue:
+		return ValueTypeNumber, current != nil
+	case *StringValue:
+		return ValueTypeString, current != nil
+	case *StringArrayValue:
+		return ValueTypeStringArray, current != nil
+	default:
+		return "", false
+	}
+}
+
+func valueTypeMaskFor(valueType ValueType) valueTypeMask {
+	switch valueType {
+	case ValueTypeBoolean:
+		return valueTypeMaskBoolean
+	case ValueTypeNumber:
+		return valueTypeMaskNumber
+	case ValueTypeString:
+		return valueTypeMaskString
+	case ValueTypeStringArray:
+		return valueTypeMaskStringArray
+	default:
+		return 0
+	}
+}
+
+func validateStringArray(values []string, path string) error {
+	if len(values) > MaxStringArrayItems {
+		return newError(ErrorCodeLimitExceeded, path, fmt.Sprintf("string array length must not exceed %d", MaxStringArrayItems))
+	}
+	for i := range values {
+		if err := validateString(values[i], fmt.Sprintf("%s[%d]", path, i)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func validateString(value string, path string) error {
+	if err := validateUnicodeString(value, path); err != nil {
+		return err
+	}
+	if utf8.RuneCountInString(value) > MaxStringLength {
+		return newError(ErrorCodeLimitExceeded, path, fmt.Sprintf("string length must not exceed %d", MaxStringLength))
+	}
+	return nil
+}
+
+func validateUnicodeString(value string, path string) error {
+	if !utf8.ValidString(value) {
+		return newError(ErrorCodeInvalidUnicode, path, "string must contain valid Unicode")
+	}
+	for _, character := range value {
+		if isUnicodeNoncharacter(character) {
+			return newError(ErrorCodeInvalidUnicode, path, "string must not contain Unicode noncharacters")
+		}
+	}
+	return nil
+}
+
+func isUnicodeNoncharacter(character rune) bool {
+	return character >= 0xFDD0 && character <= 0xFDEF ||
+		character <= utf8.MaxRune && character&0xFFFE == 0xFFFE
+}
+
+func isSnakeCode(value string, maxLength int) bool {
+	if len(value) == 0 || len(value) > maxLength || value[0] < 'a' || value[0] > 'z' {
+		return false
+	}
+	for i := 1; i < len(value); i++ {
+		character := value[i]
+		if (character < 'a' || character > 'z') && (character < '0' || character > '9') && character != '_' {
+			return false
+		}
+	}
+	return true
+}
+
+func isNamespacedCode(value string) bool {
+	if len(value) == 0 || len(value) > MaxStringLength {
+		return false
+	}
+	segmentStart := 0
+	segments := 0
+	for i := 0; i <= len(value); i++ {
+		if i < len(value) && value[i] != '.' {
+			continue
+		}
+		if !isSnakeCode(value[segmentStart:i], MaxStringLength) {
+			return false
+		}
+		segments++
+		segmentStart = i + 1
+	}
+	return segments >= 2
+}