0
0
package atprotorecord
import (
"cmp"
"context"
"encoding/json"
"errors"
"fmt"
"strconv"
"strings"
"k8s.io/apimachinery/pkg/runtime"
"k8s.io/apimachinery/pkg/runtime/schema"
"github.com/johnandersen777/socialweb-computer-kcp/api/v1alpha1"
ctlruntime "github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime"
"github.com/johnandersen777/socialweb-computer-kcp/internal/controllers/runtime/kube"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/binding"
"github.com/johnandersen777/socialweb-computer-kcp/internal/kit/strs"
)
type fieldStep struct {
name string
indexes []int
}
type absentValue struct{}
func resolveReferences(ctx context.Context, refs References, raw json.RawMessage) (json.RawMessage, []string, error) {
var value any
if len(raw) == 0 {
return nil, []string{"the record is empty"}, nil
}
if err := json.Unmarshal(raw, &value); err != nil {
return nil, nil, fmt.Errorf("the record is not valid JSON: %w", err)
}
resolved, missing := resolveValue(ctx, refs, value)
if len(missing) > 0 {
return nil, missing, nil
}
if _, absent := resolved.(absentValue); absent {
return nil, []string{"the record is an absent optional reference"}, nil
}
out, err := json.Marshal(resolved)
if err != nil {
return nil, nil, err
}
return out, nil, nil
}
func resolveValue(ctx context.Context, refs References, value any) (any, []string) {
switch typed := value.(type) {
case map[string]any:
if len(typed) == 1 {
if raw, ok := typed["valueFrom"]; ok {
from, err := decodeValueFrom(raw)
if err != nil {
return nil, []string{err.Error()}
}
return resolveReference(ctx, refs, from)
}
}
out := make(map[string]any, len(typed))
var missing []string
for key, child := range typed {
resolved, bad := resolveValue(ctx, refs, child)
if len(bad) > 0 {
missing = append(missing, bad...)
continue
}
if _, absent := resolved.(absentValue); absent {
continue
}
out[key] = resolved
}
return out, missing
case []any:
out := make([]any, 0, len(typed))
var missing []string
for _, child := range typed {
resolved, bad := resolveValue(ctx, refs, child)
if len(bad) > 0 {
missing = append(missing, bad...)
continue
}
if _, absent := resolved.(absentValue); absent {
continue
}
out = append(out, resolved)
}
return out, missing
default:
return value, nil
}
}
func decodeValueFrom(raw any) (v1alpha1.AtprotoValueFrom, error) {
body, err := json.Marshal(raw)
if err != nil {
return v1alpha1.AtprotoValueFrom{}, err
}
var from v1alpha1.AtprotoValueFrom
if err := json.Unmarshal(body, &from); err != nil {
return v1alpha1.AtprotoValueFrom{}, fmt.Errorf("the valueFrom reference: %w", err)
}
return from, nil
}
func resolveReference(ctx context.Context, refs References, from v1alpha1.AtprotoValueFrom) (any, []string) {
label := referenceLabel(from)
if strings.TrimSpace(from.Name) == "" {
return nil, []string{label + ": the reference names no object"}
}
path := parseFieldPath(from.FieldPath)
if len(path) == 0 {
return nil, []string{label + ": the reference names no fieldPath"}
}
object, err := readReference(ctx, refs, from)
if err != nil {
return nil, []string{label + ": " + err.Error()}
}
value, ok := fieldValue(object, path)
if !ok && from.Optional {
return absentValue{}, nil
}
if !ok {
return nil, []string{label + ": the field " + from.FieldPath + " is missing"}
}
return value, nil
}
func readReference(ctx context.Context, refs References, from v1alpha1.AtprotoValueFrom) (map[string]any, error) {
if refs.Own != nil {
if object, ok, err := refs.Own(ctx, from); ok {
return object, err
}
}
client := refs.Dynamic
if target := strings.TrimSpace(from.Workspace); target != "" && target != refs.Workspace {
if refs.Factory == nil {
return nil, errors.New("the reference names another workspace and no dynamic factory is configured")
}
var err error
if client, err = refs.Factory(target); err != nil {
return nil, err
}
}
if client == nil {
return nil, errors.New("no dynamic client")
}
object, err := kube.Get[map[string]any](ctx, client.Resource(ReferenceResource(from)).In(strings.TrimSpace(from.Namespace)), strings.TrimSpace(from.Name))
if err != nil {
return nil, err
}
return *object, nil
}
func ReadOwn(ctx context.Context, req ctlruntime.Request, from v1alpha1.AtprotoValueFrom) (map[string]any, bool, error) {
workspace := strings.TrimSpace(from.Workspace)
if (workspace != "" && workspace != req.Workspace) || strings.TrimSpace(from.Namespace) != "" || ReferenceResource(from).Group != v1alpha1.GroupName {
return nil, false, nil
}
kind := ReferenceKind(from)
var obj ctlruntime.Object
switch kind {
case MarketIdentityKind:
obj = &v1alpha1.MarketIdentity{}
case Kind:
obj = &v1alpha1.AtprotoRecord{}
case RecordWatchKind:
obj = &v1alpha1.AtprotoRecordWatch{}
default:
return nil, false, nil
}
if err := req.Get(ctx, "", strings.TrimSpace(from.Name), obj); err != nil {
return nil, true, err
}
obj.GetObjectKind().SetGroupVersionKind(v1alpha1.GroupVersion.WithKind(kind))
object, err := runtime.DefaultUnstructuredConverter.ToUnstructured(obj)
return object, true, err
}
func ReferenceKind(from v1alpha1.AtprotoValueFrom) string {
if kind := strings.TrimSpace(from.Kind); kind != "" {
for _, known := range OwnKinds {
if strings.EqualFold(known, kind) {
return known
}
}
return kind
}
resource := strings.TrimSpace(from.Resource)
for _, known := range OwnKinds {
if strings.EqualFold(strs.Pluralize(known), resource) {
return known
}
}
return resource
}
func ReferenceKey(workspace string, from v1alpha1.AtprotoValueFrom) string {
return binding.Key(cmp.Or(strings.TrimSpace(from.Workspace), workspace), ReferenceKind(from), strings.TrimSpace(from.Name))
}
func referenceKeys(workspace string, raw json.RawMessage) []string {
var value any
if len(raw) == 0 || json.Unmarshal(raw, &value) != nil {
return nil
}
var out []string
var walk func(any)
walk = func(v any) {
switch typed := v.(type) {
case map[string]any:
if len(typed) == 1 {
if raw, ok := typed["valueFrom"]; ok {
if from, err := decodeValueFrom(raw); err == nil && strings.TrimSpace(from.Name) != "" {
out = append(out, ReferenceKey(workspace, from))
}
return
}
}
for _, child := range typed {
walk(child)
}
case []any:
for _, child := range typed {
walk(child)
}
}
}
walk(value)
return out
}
func referenceLabel(from v1alpha1.AtprotoValueFrom) string {
kind := strings.TrimSpace(from.Kind)
if kind == "" {
kind = strings.TrimSpace(from.Resource)
}
return kind + " " + strings.TrimSpace(from.Name) + " " + strings.TrimSpace(from.FieldPath)
}
func ReferenceResource(from v1alpha1.AtprotoValueFrom) schema.GroupVersionResource {
group := v1alpha1.GroupName
version := v1alpha1.Version
if raw := strings.TrimSpace(from.ApiVersion); raw != "" {
if parsed, err := schema.ParseGroupVersion(raw); err == nil {
group, version = parsed.Group, parsed.Version
}
}
resource := strings.TrimSpace(from.Resource)
if resource == "" {
resource = strs.Pluralize(from.Kind)
}
return schema.GroupVersion{Group: group, Version: version}.WithResource(resource)
}
func parseFieldPath(raw string) []fieldStep {
raw = strings.TrimSpace(raw)
if raw == "" {
return nil
}
var out []fieldStep
for part := range strings.SplitSeq(raw, ".") {
part = strings.TrimSpace(part)
if part == "" {
continue
}
name := part
var indexes []int
if open := strings.IndexByte(part, '['); open >= 0 {
name = part[:open]
rest := part[open:]
for strings.HasPrefix(rest, "[") {
close := strings.IndexByte(rest, ']')
if close < 0 {
return nil
}
index, err := strconv.Atoi(strings.TrimSpace(rest[1:close]))
if err != nil || index < 0 {
return nil
}
indexes = append(indexes, index)
rest = rest[close+1:]
}
if rest != "" {
return nil
}
}
if name == "" {
return nil
}
out = append(out, fieldStep{name: name, indexes: indexes})
}
return out
}
func fieldValue(object map[string]any, path []fieldStep) (any, bool) {
var current any = object
for _, step := range path {
fields, ok := current.(map[string]any)
if !ok {
return nil, false
}
current, ok = fields[step.name]
if !ok {
return nil, false
}
for _, index := range step.indexes {
items, ok := current.([]any)
if !ok || index >= len(items) {
return nil, false
}
current = items[index]
}
}
return current, true
}