@stackonward/cli 0.0.1 → 1.0.1

package/dist/resources/templates/go-backend/internal/common/runtimeinput/runtime_input.go

@@ -0,0 +1,627 @@
+package runtimeinput
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+const (
+	PolicySideBySide720        = "side_by_side_720_v1"
+	PolicyDualImagePassthrough = "dual_image_passthrough_v1"
+)
+
+type Object map[string]any // T1: 运行时输入与转换 DSL 是 schema 定义的异构 JSON 对象。
+
+type AssetRef struct {
+	Source  string `json:"source"`
+	AssetID int64  `json:"asset_id,omitempty"`
+	URL     string `json:"url,omitempty"`
+}
+
+type NormalizationPolicyRule struct {
+	PolicyCode         string `json:"policy_code"`
+	OutputMode         string `json:"output_mode"`
+	SourceField        string `json:"source_field"`
+	OutputField        string `json:"output_field"`
+	PreserveOriginalTo string `json:"preserve_original_to"`
+}
+
+func NormalizePolicyRule(rule NormalizationPolicyRule) NormalizationPolicyRule {
+	rule.PolicyCode = strings.TrimSpace(rule.PolicyCode)
+	rule.OutputMode = strings.TrimSpace(rule.OutputMode)
+	rule.SourceField = strings.TrimSpace(rule.SourceField)
+	rule.OutputField = strings.TrimSpace(rule.OutputField)
+	rule.PreserveOriginalTo = strings.TrimSpace(rule.PreserveOriginalTo)
+	return rule
+}
+
+func ValidateNormalizationPolicyRule(rule NormalizationPolicyRule, requestedMode string, runtimeMode string) error {
+	normalized := NormalizePolicyRule(rule)
+	switch normalized.PolicyCode {
+	case PolicySideBySide720:
+		return validateSideBySide720Rule(normalized, requestedMode, runtimeMode)
+	case PolicyDualImagePassthrough:
+		return validateDualImagePassthroughRule(normalized, requestedMode)
+	default:
+		return fmt.Errorf("input_normalization_policy policy_code is not supported")
+	}
+}
+
+func validateSideBySide720Rule(normalized NormalizationPolicyRule, requestedMode string, runtimeMode string) error {
+	if strings.TrimSpace(requestedMode) != "dual_image" {
+		return fmt.Errorf("input_normalization_policy requested input mode is not supported")
+	}
+	if normalized.OutputMode != strings.TrimSpace(runtimeMode) {
+		return fmt.Errorf("input_normalization_policy output_mode must match runtime input mode")
+	}
+	if normalized.SourceField != "input_assets" || normalized.OutputField != "input_assets" || normalized.PreserveOriginalTo != "source_input_assets" {
+		return fmt.Errorf("input_normalization_policy must use durable input asset fields")
+	}
+	if normalized.SourceField == "" || normalized.OutputField == "" || normalized.PreserveOriginalTo == "" {
+		return fmt.Errorf("input_normalization_policy rule is incomplete")
+	}
+	return nil
+}
+
+func validateDualImagePassthroughRule(normalized NormalizationPolicyRule, requestedMode string) error {
+	if strings.TrimSpace(requestedMode) != "dual_image" {
+		return fmt.Errorf("input_normalization_policy requested input mode is not supported")
+	}
+	if normalized.OutputMode != "dual_image" {
+		return fmt.Errorf("input_normalization_policy output_mode must be dual_image")
+	}
+	if normalized.SourceField != "input_assets" || normalized.OutputField != "input_assets" {
+		return fmt.Errorf("input_normalization_policy must use durable input asset fields")
+	}
+	if normalized.SourceField == "" || normalized.OutputField == "" {
+		return fmt.Errorf("input_normalization_policy rule is incomplete")
+	}
+	return nil
+}
+
+// MergeJSONObjects 按顺序合并多个 JSON 对象，后者覆盖前者。
+func MergeJSONObjects(payloads ...json.RawMessage) (Object, error) {
+	merged := make(Object)
+	for _, payload := range payloads {
+		if len(payload) == 0 {
+			continue
+		}
+		doc, err := DecodeJSONObject(payload)
+		if err != nil {
+			return nil, err
+		}
+		for key, value := range doc {
+			merged[key] = value
+		}
+	}
+	return merged, nil
+}
+
+// MergeInputObject 将输入 JSON 对象合并到目标 map。
+func MergeInputObject(target Object, input json.RawMessage) error {
+	if len(input) == 0 {
+		return nil
+	}
+	doc, err := DecodeJSONObject(input)
+	if err != nil {
+		return err
+	}
+	for key, value := range doc {
+		target[key] = value
+	}
+	return nil
+}
+
+// DecodeJSONObject 将 JSON 对象解码为 map。
+func DecodeJSONObject(payload json.RawMessage) (Object, error) {
+	doc := make(Object)
+	if err := json.Unmarshal(payload, &doc); err != nil {
+		return nil, err
+	}
+	return doc, nil
+}
+
+// ApplyInputTransform 执行 x-input-transform 规则。
+func ApplyInputTransform(params Object) error {
+	if len(params) == 0 {
+		return nil
+	}
+
+	raw, ok := params["x-input-transform"]
+	if !ok || raw == nil {
+		return nil
+	}
+	delete(params, "x-input-transform")
+
+	transform, ok := transformObject(raw)
+	if !ok {
+		return fmt.Errorf("execution input transform is invalid")
+	}
+	if err := applyPickFirstTransform(params, transform["pick_first"]); err != nil {
+		return err
+	}
+	if err := applyPickIndexTransform(params, transform["pick_index"]); err != nil {
+		return err
+	}
+	if err := applyCopyArrayTransform(params, transform["copy_array"]); err != nil {
+		return err
+	}
+	if err := applyFieldMapTransform(params, transform["map_fields"]); err != nil {
+		return err
+	}
+	if err := applyArrayItemsFromStringsTransform(params, transform["array_items_from_strings"]); err != nil {
+		return err
+	}
+	if err := applyMoveFieldsTransform(params, transform["move_fields"]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func applyPickIndexTransform(params Object, raw any) error {
+	if raw == nil {
+		return nil
+	}
+	items, ok := raw.([]any)
+	if !ok {
+		return fmt.Errorf("execution input indexed transform is invalid")
+	}
+
+	deleteSources := make(map[string]struct{}, len(items))
+	for i := range items {
+		item, ok := transformObject(items[i])
+		if !ok {
+			return fmt.Errorf("execution input indexed transform item is invalid")
+		}
+		sourceField, _ := item["source"].(string)
+		targetField, _ := item["target"].(string)
+		if strings.TrimSpace(sourceField) == "" || strings.TrimSpace(targetField) == "" {
+			return fmt.Errorf("execution input indexed transform is incomplete")
+		}
+		rawIndex, exists := item["index"]
+		if !exists {
+			return fmt.Errorf("execution input indexed transform index is missing")
+		}
+		index, err := transformIndex(rawIndex)
+		if err != nil {
+			return err
+		}
+		values, ok := ExtractStringArray(params[sourceField])
+		if !ok || index < 0 || index >= len(values) {
+			continue
+		}
+		params[targetField] = values[index]
+		deleteSources[sourceField] = struct{}{}
+	}
+	for sourceField := range deleteSources {
+		delete(params, sourceField)
+	}
+	return nil
+}
+
+func applyPickFirstTransform(params Object, raw any) error {
+	mappings, err := decodeTransformStringMap(raw)
+	if err != nil {
+		return err
+	}
+	for sourceField, targetField := range mappings {
+		values, ok := ExtractStringArray(params[sourceField])
+		if !ok || len(values) == 0 {
+			continue
+		}
+		params[targetField] = values[0]
+		delete(params, sourceField)
+	}
+	return nil
+}
+
+func applyCopyArrayTransform(params Object, raw any) error {
+	mappings, err := decodeTransformStringMap(raw)
+	if err != nil {
+		return err
+	}
+	for sourceField, targetField := range mappings {
+		values, ok := ExtractStringArray(params[sourceField])
+		if !ok || len(values) == 0 {
+			continue
+		}
+		params[targetField] = values
+		delete(params, sourceField)
+	}
+	return nil
+}
+
+func applyFieldMapTransform(params Object, raw any) error {
+	if raw == nil {
+		return nil
+	}
+	items, ok := raw.([]any)
+	if !ok {
+		return fmt.Errorf("execution input field mapping is invalid")
+	}
+	for i := range items {
+		item, ok := transformObject(items[i])
+		if !ok {
+			return fmt.Errorf("execution input field mapping item is invalid")
+		}
+		sourceField, _ := item["source"].(string)
+		targetField, _ := item["target"].(string)
+		if strings.TrimSpace(sourceField) == "" || strings.TrimSpace(targetField) == "" {
+			return fmt.Errorf("execution input field mapping is incomplete")
+		}
+		value, exists := params[sourceField]
+		if !exists {
+			continue
+		}
+		if rawValues, hasValues := item["values"]; hasValues {
+			values, ok := transformObject(rawValues)
+			if !ok {
+				return fmt.Errorf("execution input field mapping values are invalid")
+			}
+			if mapped, ok := values[fmt.Sprint(value)]; ok {
+				value = mapped
+			}
+		}
+		params[targetField] = value
+		if sourceField != targetField {
+			delete(params, sourceField)
+		}
+	}
+	return nil
+}
+
+func applyArrayItemsFromStringsTransform(params Object, raw any) error {
+	if raw == nil {
+		return nil
+	}
+	items, ok := raw.([]any)
+	if !ok {
+		return fmt.Errorf("execution input array item transform is invalid")
+	}
+	for i := range items {
+		item, ok := transformObject(items[i])
+		if !ok {
+			return fmt.Errorf("execution input array item transform item is invalid")
+		}
+		sourceField, _ := item["source"].(string)
+		targetPath, _ := item["target"].(string)
+		if strings.TrimSpace(sourceField) == "" || strings.TrimSpace(targetPath) == "" {
+			return fmt.Errorf("execution input array item transform is incomplete")
+		}
+		valueField := "value"
+		if configuredValueField, ok := item["value_field"].(string); ok && strings.TrimSpace(configuredValueField) != "" {
+			valueField = strings.TrimSpace(configuredValueField)
+		}
+		if strings.Contains(valueField, ".") {
+			return fmt.Errorf("execution input array item transform value_field must be a leaf field")
+		}
+		if strings.Contains(valueField, " ") {
+			return fmt.Errorf("execution input array item transform value_field is invalid")
+		}
+		if valueField == "" {
+			valueField = "value"
+		}
+		itemFields := Object{}
+		if rawItemFields, exists := item["item_fields"]; exists {
+			fields, ok := transformObject(rawItemFields)
+			if !ok {
+				return fmt.Errorf("execution input array item transform item_fields are invalid")
+			}
+			itemFields = fields
+		}
+		indexedItemFields, err := decodeIndexedItemFields(item["indexed_item_fields"])
+		if err != nil {
+			return err
+		}
+		values, ok := ExtractStringArray(params[sourceField])
+		if !ok || len(values) == 0 {
+			continue
+		}
+		objects := make([]any, 0, len(values))
+		for index, value := range values {
+			indexFields := indexedItemFields[index]
+			next := make(Object, len(itemFields)+len(indexFields)+1)
+			for key, fieldValue := range itemFields {
+				next[key] = fieldValue
+			}
+			for key, fieldValue := range indexFields {
+				next[key] = fieldValue
+			}
+			next[valueField] = value
+			objects = append(objects, next)
+		}
+		if err := setNestedValue(params, targetPath, objects); err != nil {
+			return err
+		}
+		delete(params, sourceField)
+	}
+	return nil
+}
+
+func decodeIndexedItemFields(raw any) (map[int]Object, error) {
+	if raw == nil {
+		return map[int]Object{}, nil
+	}
+	items, ok := raw.([]any)
+	if !ok {
+		return nil, fmt.Errorf("execution input array item transform indexed_item_fields are invalid")
+	}
+	result := make(map[int]Object, len(items))
+	for i := range items {
+		item, ok := transformObject(items[i])
+		if !ok {
+			return nil, fmt.Errorf("execution input array item transform indexed_item_fields item is invalid")
+		}
+		rawIndex, exists := item["index"]
+		if !exists {
+			return nil, fmt.Errorf("execution input array item transform indexed_item_fields index is missing")
+		}
+		index, err := transformArrayItemIndex(rawIndex)
+		if err != nil {
+			return nil, err
+		}
+		if _, exists := result[index]; exists {
+			return nil, fmt.Errorf("execution input array item transform indexed_item_fields index is duplicated")
+		}
+		rawFields, exists := item["fields"]
+		if !exists {
+			return nil, fmt.Errorf("execution input array item transform indexed_item_fields fields are missing")
+		}
+		fields, ok := transformObject(rawFields)
+		if !ok {
+			return nil, fmt.Errorf("execution input array item transform indexed_item_fields fields are invalid")
+		}
+		result[index] = fields
+	}
+	return result, nil
+}
+
+func applyMoveFieldsTransform(params Object, raw any) error {
+	if raw == nil {
+		return nil
+	}
+	items, ok := raw.([]any)
+	if !ok {
+		return fmt.Errorf("execution input move fields transform is invalid")
+	}
+	for i := range items {
+		item, ok := transformObject(items[i])
+		if !ok {
+			return fmt.Errorf("execution input move fields transform item is invalid")
+		}
+		sourceField, _ := item["source"].(string)
+		targetPath, _ := item["target"].(string)
+		if strings.TrimSpace(sourceField) == "" || strings.TrimSpace(targetPath) == "" {
+			return fmt.Errorf("execution input move fields transform is incomplete")
+		}
+		value, exists := params[sourceField]
+		if !exists {
+			continue
+		}
+		if rawValues, hasValues := item["values"]; hasValues {
+			values, ok := transformObject(rawValues)
+			if !ok {
+				return fmt.Errorf("execution input move fields transform values are invalid")
+			}
+			if mapped, ok := values[fmt.Sprint(value)]; ok {
+				value = mapped
+			}
+		}
+		if err := setNestedValue(params, targetPath, value); err != nil {
+			return err
+		}
+		if sourceField != targetPath {
+			delete(params, sourceField)
+		}
+	}
+	return nil
+}
+
+func decodeTransformStringMap(raw any) (map[string]string, error) {
+	if raw == nil {
+		return map[string]string{}, nil
+	}
+	items, ok := transformObject(raw)
+	if !ok {
+		return nil, fmt.Errorf("execution input transform mapping is invalid")
+	}
+	result := make(map[string]string, len(items))
+	for sourceField, targetValue := range items {
+		targetField, ok := targetValue.(string)
+		if !ok || strings.TrimSpace(targetField) == "" {
+			return nil, fmt.Errorf("execution input transform target field is invalid")
+		}
+		result[sourceField] = targetField
+	}
+	return result, nil
+}
+
+func transformObject(raw any) (map[string]any, bool) {
+	switch v := raw.(type) {
+	case Object:
+		return map[string]any(v), true
+	case map[string]any:
+		return v, true
+	default:
+		return nil, false
+	}
+}
+
+func setNestedValue(params Object, targetPath string, value any) error { // T1: value 由 JSON DSL 决定。
+	segments := strings.Split(strings.TrimSpace(targetPath), ".")
+	if len(segments) == 0 {
+		return fmt.Errorf("execution input transform target path is invalid")
+	}
+	current := params
+	for i := 0; i < len(segments)-1; i++ {
+		segment := strings.TrimSpace(segments[i])
+		if segment == "" {
+			return fmt.Errorf("execution input transform target path is invalid")
+		}
+		rawChild, exists := current[segment]
+		if !exists {
+			child := Object{}
+			current[segment] = child
+			current = child
+			continue
+		}
+		child, ok := transformObject(rawChild)
+		if !ok {
+			return fmt.Errorf("execution input transform target path conflicts with scalar field")
+		}
+		current = child
+	}
+	leaf := strings.TrimSpace(segments[len(segments)-1])
+	if leaf == "" {
+		return fmt.Errorf("execution input transform target path is invalid")
+	}
+	current[leaf] = value
+	return nil
+}
+
+// ExtractStringArray 从 mixed JSON 值中提取非空字符串数组。
+func ExtractStringArray(raw any) ([]string, bool) {
+	switch v := raw.(type) {
+	case []string:
+		if len(v) == 0 {
+			return nil, false
+		}
+		return v, true
+	case []any:
+		result := make([]string, 0, len(v))
+		for i := range v {
+			item, ok := v[i].(string)
+			if ok && strings.TrimSpace(item) != "" {
+				result = append(result, item)
+			}
+		}
+		if len(result) == 0 {
+			return nil, false
+		}
+		return result, true
+	default:
+		return nil, false
+	}
+}
+
+// ExtractStrictStringArray 从 JSON 值中提取非空字符串数组，不接受非数组或空字符串成员。
+func ExtractStrictStringArray(raw any, fieldName string) ([]string, error) {
+	if raw == nil {
+		return []string{}, nil
+	}
+	items, ok := raw.([]any)
+	if !ok {
+		return nil, fmt.Errorf("%s must be an array of strings", fieldName)
+	}
+	values := make([]string, 0, len(items))
+	for i := range items {
+		value, ok := items[i].(string)
+		if !ok {
+			return nil, fmt.Errorf("%s must be an array of strings", fieldName)
+		}
+		trimmed := strings.TrimSpace(value)
+		if trimmed == "" {
+			return nil, fmt.Errorf("%s must not contain empty URL", fieldName)
+		}
+		values = append(values, trimmed)
+	}
+	return values, nil
+}
+
+func ExtractAssetRefs(raw any, fieldName string) ([]AssetRef, error) {
+	if raw == nil {
+		return []AssetRef{}, nil
+	}
+	items, ok := raw.([]any)
+	if !ok {
+		return nil, fmt.Errorf("%s must be an array of asset references", fieldName)
+	}
+	refs := make([]AssetRef, 0, len(items))
+	for i := range items {
+		item, ok := transformObject(items[i])
+		if !ok {
+			return nil, fmt.Errorf("%s must be an array of asset references", fieldName)
+		}
+		ref := AssetRef{
+			Source: trimOptionalString(item["source"]),
+			URL:    trimOptionalString(item["url"]),
+		}
+		switch value := item["asset_id"].(type) {
+		case float64:
+			ref.AssetID = int64(value)
+		case int:
+			ref.AssetID = int64(value)
+		case int64:
+			ref.AssetID = value
+		case json.Number:
+			assetID, err := value.Int64()
+			if err != nil {
+				return nil, fmt.Errorf("%s asset_id is invalid", fieldName)
+			}
+			ref.AssetID = assetID
+		case nil:
+		default:
+			return nil, fmt.Errorf("%s asset_id is invalid", fieldName)
+		}
+		if ref.Source == "" {
+			return nil, fmt.Errorf("%s source is required", fieldName)
+		}
+		refs = append(refs, ref)
+	}
+	return refs, nil
+}
+
+func trimOptionalString(raw any) string {
+	if raw == nil {
+		return ""
+	}
+	value, ok := raw.(string)
+	if !ok {
+		return ""
+	}
+	return strings.TrimSpace(value)
+}
+
+func transformIndex(raw any) (int, error) {
+	switch v := raw.(type) {
+	case float64:
+		return int(v), nil
+	case int:
+		return v, nil
+	case int32:
+		return int(v), nil
+	case int64:
+		return int(v), nil
+	default:
+		return 0, fmt.Errorf("execution input indexed transform index is invalid")
+	}
+}
+
+func transformArrayItemIndex(raw any) (int, error) {
+	switch v := raw.(type) {
+	case float64:
+		index := int(v)
+		if v < 0 || v != float64(index) {
+			return 0, fmt.Errorf("execution input array item transform indexed_item_fields index is invalid")
+		}
+		return index, nil
+	case int:
+		if v < 0 {
+			return 0, fmt.Errorf("execution input array item transform indexed_item_fields index is invalid")
+		}
+		return v, nil
+	case int32:
+		if v < 0 {
+			return 0, fmt.Errorf("execution input array item transform indexed_item_fields index is invalid")
+		}
+		return int(v), nil
+	case int64:
+		if v < 0 {
+			return 0, fmt.Errorf("execution input array item transform indexed_item_fields index is invalid")
+		}
+		return int(v), nil
+	default:
+		return 0, fmt.Errorf("execution input array item transform indexed_item_fields index is invalid")
+	}
+}