0
0
package eventstream
import (
"context"
"encoding/json"
"errors"
"fmt"
"strconv"
"strings"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
)
type Match struct {
FieldPath []string
Value string
}
type ValueFunc func(ctx context.Context, from v1alpha1.AtprotoValueFrom) (map[string]any, error)
func ResolveMatches(ctx context.Context, spec []v1alpha1.AtprotoRecordMatch, value ValueFunc) ([]Match, error) {
if len(spec) == 0 {
return nil, nil
}
out := make([]Match, 0, len(spec))
for _, match := range spec {
path := splitFieldPath(match.FieldPath)
if len(path) == 0 {
return nil, errors.New("eventstream: a match needs a fieldPath")
}
resolved, err := matchValue(ctx, match, value)
if err != nil {
return nil, err
}
out = append(out, Match{FieldPath: path, Value: resolved})
}
return out, nil
}
func matchValue(ctx context.Context, match v1alpha1.AtprotoRecordMatch, value ValueFunc) (string, error) {
if match.ValueFrom == nil {
return match.Value, nil
}
from := *match.ValueFrom
if strings.TrimSpace(from.Name) == "" {
return "", errors.New("eventstream: a match valueFrom needs a name")
}
path := splitFieldPath(from.FieldPath)
if len(path) == 0 {
return "", errors.New("eventstream: a match valueFrom needs a fieldPath")
}
if value == nil {
return "", fmt.Errorf("eventstream: match valueFrom %s %s has no reader", from.Kind, from.Name)
}
object, err := value(ctx, from)
if err != nil {
return "", fmt.Errorf("eventstream: match valueFrom %s %s: %w", from.Kind, from.Name, err)
}
resolved, ok := recordFieldString(object, path)
if !ok {
return "", fmt.Errorf("eventstream: field %s is missing", strings.Join(path, "."))
}
return resolved, nil
}
func splitFieldPath(path string) []string {
trimmed := strings.TrimSpace(path)
if trimmed == "" {
return nil
}
parts := strings.Split(trimmed, ".")
out := make([]string, 0, len(parts))
for _, part := range parts {
part = strings.TrimSpace(part)
if part != "" {
out = append(out, part)
}
}
return out
}
func scalarString(value any) string {
switch typed := value.(type) {
case nil:
return ""
case string:
return typed
case bool:
return strconv.FormatBool(typed)
case int64:
return strconv.FormatInt(typed, 10)
case int:
return strconv.Itoa(typed)
case float64:
if typed == float64(int64(typed)) {
return strconv.FormatInt(int64(typed), 10)
}
return strconv.FormatFloat(typed, 'f', -1, 64)
case json.Number:
return typed.String()
default:
raw, err := json.Marshal(typed)
if err != nil {
return fmt.Sprint(typed)
}
return string(raw)
}
}
func recordFieldString(value any, path []string) (string, bool) {
current := value
for _, part := range path {
object, ok := current.(map[string]any)
if !ok {
return "", false
}
current, ok = object[part]
if !ok {
return "", false
}
}
return scalarString(current), true
}
func MatchesRecord(value json.RawMessage, matches []Match) bool {
var decoded any
if err := json.Unmarshal(value, &decoded); err != nil {
return false
}
for _, match := range matches {
actual, ok := recordFieldString(decoded, match.FieldPath)
if !ok || actual != match.Value {
return false
}
}
return true
}