+
+
package path
+
+import "time"
+
+func Equal(obj any, path string, matchStr string) (bool, error) {
+ return op(obj, path, matchStr, equal)
+}
+
+func equal(obj, match any, _ string) bool {
+ switch objt := obj.(type) {
+ case time.Time:
+ tm := match.(*timeVal)
+
+ // TODO: Replace Truncate() with a timezone-aware version
+ return tm.time.Equal(objt.Truncate(tm.precision))
+
+ default:
+ return obj == match
+ }
+}
+
+
+
package path
+
+import (
+ "time"
+
+ "cloud.google.com/go/civil"
+)
+
+func Greater(obj any, path string, matchStr string) (bool, error) {
+ return op(obj, path, matchStr, greater)
+}
+
+func greater(obj, match any, _ string) bool {
+ switch objt := obj.(type) {
+ case int:
+ return objt > match.(int)
+
+ case int64:
+ return objt > match.(int64)
+
+ case uint:
+ return objt > match.(uint)
+
+ case uint64:
+ return objt > match.(uint64)
+
+ case float32:
+ return objt > match.(float32)
+
+ case float64:
+ return objt > match.(float64)
+
+ case string:
+ return objt > match.(string)
+
+ case bool:
+ return objt && !match.(bool)
+
+ case time.Time:
+ tm := match.(*timeVal)
+
+ return objt.Truncate(tm.precision).After(tm.time)
+
+ case civil.Date:
+ return objt.After(match.(civil.Date))
+
+ default:
+ panic(obj)
+ }
+}
+
+
+
package path
+
+import (
+ "time"
+
+ "cloud.google.com/go/civil"
+)
+
+func GreaterEqual(obj any, path string, matchStr string) (bool, error) {
+ return op(obj, path, matchStr, greaterEqual)
+}
+
+func greaterEqual(obj, match any, _ string) bool {
+ switch objt := obj.(type) {
+ case int:
+ return objt >= match.(int)
+
+ case int64:
+ return objt >= match.(int64)
+
+ case uint:
+ return objt >= match.(uint)
+
+ case uint64:
+ return objt >= match.(uint64)
+
+ case float32:
+ return objt >= match.(float32)
+
+ case float64:
+ return objt >= match.(float64)
+
+ case string:
+ return objt >= match.(string)
+
+ case bool:
+ return objt || objt == match.(bool)
+
+ case time.Time:
+ tm := match.(*timeVal)
+ trunc := objt.Truncate(tm.precision)
+
+ return trunc.Equal(tm.time) || trunc.After(tm.time)
+
+ case civil.Date:
+ return objt == match.(civil.Date) || objt.After(match.(civil.Date))
+
+ default:
+ panic(obj)
+ }
+}
+
+
+
package path
+
+import (
+ "strconv"
+ "strings"
+ "time"
+
+ "cloud.google.com/go/civil"
+)
+
+func HasPrefix(obj any, path string, matchStr string) (bool, error) {
+ return op(obj, path, matchStr, hasPrefix)
+}
+
+func hasPrefix(obj, match any, matchStr string) bool {
+ var objStr string
+
+ switch objt := obj.(type) {
+ case int:
+ objStr = strconv.FormatInt(int64(objt), 10)
+
+ case int64:
+ objStr = strconv.FormatInt(objt, 10)
+
+ case uint:
+ objStr = strconv.FormatUint(uint64(objt), 10)
+
+ case uint64:
+ objStr = strconv.FormatUint(objt, 10)
+
+ case float32:
+ objStr = strconv.FormatFloat(float64(objt), 'f', -1, 32)
+
+ case float64:
+ objStr = strconv.FormatFloat(objt, 'f', -1, 64)
+
+ case string:
+ objStr = objt
+
+ case bool:
+ objStr = strconv.FormatBool(objt)
+
+ case time.Time:
+ objStr = objt.String()
+
+ case civil.Date:
+ objStr = objt.String()
+
+ default:
+ panic(obj)
+ }
+
+ return strings.HasPrefix(objStr, matchStr)
+}
+
+
+
package path
+
+func In(obj any, path string, matchStr string) (bool, error) {
+ return opList(obj, path, matchStr, equal)
+}
+
+
+
package path
+
+import (
+ "time"
+
+ "cloud.google.com/go/civil"
+)
+
+func Less(obj any, path string, matchStr string) (bool, error) {
+ return op(obj, path, matchStr, less)
+}
+
+func less(obj, match any, _ string) bool {
+ switch objt := obj.(type) {
+ case int:
+ return objt < match.(int)
+
+ case int64:
+ return objt < match.(int64)
+
+ case uint:
+ return objt < match.(uint)
+
+ case uint64:
+ return objt < match.(uint64)
+
+ case float32:
+ return objt < match.(float32)
+
+ case float64:
+ return objt < match.(float64)
+
+ case string:
+ return objt < match.(string)
+
+ case bool:
+ return !objt && match.(bool)
+
+ case time.Time:
+ tm := match.(*timeVal)
+
+ return objt.Truncate(tm.precision).Before(tm.time)
+
+ case civil.Date:
+ return objt.Before(match.(civil.Date))
+
+ default:
+ panic(obj)
+ }
+}
+
+
+
package path
+
+import (
+ "time"
+
+ "cloud.google.com/go/civil"
+)
+
+func LessEqual(obj any, path string, matchStr string) (bool, error) {
+ return op(obj, path, matchStr, lessEqual)
+}
+
+func lessEqual(obj, match any, _ string) bool {
+ switch objt := obj.(type) {
+ case int:
+ return objt <= match.(int)
+
+ case int64:
+ return objt <= match.(int64)
+
+ case uint:
+ return objt <= match.(uint)
+
+ case uint64:
+ return objt <= match.(uint64)
+
+ case float32:
+ return objt <= match.(float32)
+
+ case float64:
+ return objt <= match.(float64)
+
+ case string:
+ return objt <= match.(string)
+
+ case bool:
+ return !objt || objt == match.(bool)
+
+ case time.Time:
+ tm := match.(*timeVal)
+ trunc := objt.Truncate(tm.precision)
+
+ return trunc.Equal(tm.time) || trunc.Before(tm.time)
+
+ case civil.Date:
+ return objt == match.(civil.Date) || objt.Before(match.(civil.Date))
+
+ default:
+ panic(obj)
+ }
+}
+
+
+
package path
+
+import (
+ "encoding/json"
+ "reflect"
+
+ "github.com/gopatchy/jsrest"
+)
+
+func Merge(to, from any) {
+ MergeValue(reflect.ValueOf(to), reflect.ValueOf(from))
+}
+
+func MergeValue(to, from reflect.Value) {
+ to = reflect.Indirect(to)
+ from = reflect.Indirect(from)
+
+ for i := 0; i < to.NumField(); i++ {
+ toField := to.Field(i)
+ fromField := from.Field(i)
+
+ if fromField.IsZero() {
+ continue
+ }
+
+ if reflect.Indirect(fromField).Kind() == reflect.Struct {
+ MergeValue(toField, fromField)
+ continue
+ }
+
+ toField.Set(fromField)
+ }
+}
+
+func MergeMap(to any, from map[string]any) error {
+ m, err := ToMap(to)
+ if err != nil {
+ return jsrest.Errorf(jsrest.ErrInternalServerError, "converting to map failed (%w)", err)
+ }
+
+ MergeMaps(m, from)
+
+ return FromMap(to, m)
+}
+
+func MergeMaps(to map[string]any, from map[string]any) {
+ for k, v := range from {
+ if vMap, isMap := v.(map[string]any); isMap {
+ if _, ok := to[k].(map[string]any); !ok {
+ // Either key doesn't exist or it's a different type
+ // If different type, error will happen during json decode
+ to[k] = map[string]any{}
+ }
+
+ MergeMaps(to[k].(map[string]any), vMap)
+ } else {
+ to[k] = v
+ }
+ }
+}
+
+func ToMap(from any) (map[string]any, error) {
+ js, err := json.Marshal(from)
+ if err != nil {
+ return nil, jsrest.Errorf(jsrest.ErrInternalServerError, "json marshal failed (%w)", err)
+ }
+
+ ret := map[string]any{}
+
+ err = json.Unmarshal(js, &ret)
+ if err != nil {
+ return nil, jsrest.Errorf(jsrest.ErrInternalServerError, "json unmarshal failed (%w)", err)
+ }
+
+ return ret, nil
+}
+
+func FromMap(to any, from map[string]any) error {
+ js, err := json.Marshal(from)
+ if err != nil {
+ return jsrest.Errorf(jsrest.ErrInternalServerError, "json marshal failed (%w)", err)
+ }
+
+ err = json.Unmarshal(js, to)
+ if err != nil {
+ return jsrest.Errorf(jsrest.ErrInternalServerError, "json unmarshal failed (%w)", err)
+ }
+
+ return nil
+}
+
+
+
package path
+
+import (
+ "strings"
+)
+
+func op(obj any, path string, matchStr string, cb func(any, any, string) bool) (bool, error) {
+ objVal, err := Get(obj, path)
+ if err != nil {
+ return false, err
+ }
+
+ matchVal, err := parse(matchStr, objVal)
+ if err != nil {
+ return false, err
+ }
+
+ if isSlice(objVal) {
+ return anyTrue(objVal, func(x any, _ int) bool { return cb(x, matchVal, matchStr) }), nil
+ }
+
+ return cb(objVal, matchVal, matchStr), nil
+}
+
+func opList(obj any, path string, matchStr string, cb func(any, any, string) bool) (bool, error) {
+ objVal, err := Get(obj, path)
+ if err != nil {
+ return false, err
+ }
+
+ if objVal == nil {
+ return false, nil
+ }
+
+ matchVal := []any{}
+ matchParts := strings.Split(matchStr, ",")
+
+ for _, matchPart := range matchParts {
+ matchTmp, err := parse(matchPart, objVal)
+ if err != nil {
+ return false, err
+ }
+
+ matchVal = append(matchVal, matchTmp)
+ }
+
+ return anyTrue(matchVal, func(y any, i int) bool {
+ str := matchParts[i]
+
+ if isSlice(objVal) {
+ return anyTrue(objVal, func(x any, _ int) bool { return cb(x, y, str) })
+ }
+
+ return cb(objVal, y, str)
+ }), nil
+}
+
+
+
package path
+
+import (
+ "errors"
+ "reflect"
+ "strconv"
+ "strings"
+ "time"
+
+ "cloud.google.com/go/civil"
+ "github.com/gopatchy/jsrest"
+)
+
+type timeVal struct {
+ time time.Time
+ precision time.Duration
+}
+
+var (
+ ErrUnsupportedType = errors.New("unsupported type")
+ ErrUnknownTimeFormat = errors.New("unknown time format")
+)
+
+func parse(str string, t any) (any, error) {
+ typ := reflect.TypeOf(t)
+
+ if typ.Kind() == reflect.Slice {
+ typ = typ.Elem()
+ }
+
+ if typ.Kind() == reflect.Pointer {
+ typ = typ.Elem()
+ }
+
+ // TODO: Consider attempting to convert to string in default case
+ switch typ.Kind() { //nolint:exhaustive
+ case reflect.Int:
+ return parseInt(str)
+
+ case reflect.Int64:
+ return strconv.ParseInt(str, 10, 64)
+
+ case reflect.Uint:
+ return parseUint(str)
+
+ case reflect.Uint64:
+ return strconv.ParseUint(str, 10, 64)
+
+ case reflect.Float32:
+ return parseFloat32(str)
+
+ case reflect.Float64:
+ return strconv.ParseFloat(str, 64)
+
+ case reflect.String:
+ return str, nil
+
+ case reflect.Bool:
+ return strconv.ParseBool(str)
+
+ case reflect.Struct:
+ switch typ {
+ case reflect.TypeOf(time.Time{}):
+ return parseTime(str)
+
+ case reflect.TypeOf(civil.Date{}):
+ return civil.ParseDate(str)
+ }
+ }
+
+ return nil, jsrest.Errorf(jsrest.ErrBadRequest, "%T (%w)", t, ErrUnsupportedType)
+}
+
+func parseInt(str string) (int, error) {
+ val, err := strconv.ParseInt(str, 10, strconv.IntSize)
+
+ return int(val), err
+}
+
+func parseUint(str string) (uint, error) {
+ val, err := strconv.ParseUint(str, 10, strconv.IntSize)
+
+ return uint(val), err
+}
+
+func parseFloat32(str string) (float32, error) {
+ val, err := strconv.ParseFloat(str, 32)
+
+ return float32(val), err
+}
+
+type timeFormat struct {
+ format string
+ precision time.Duration
+}
+
+var timeFormats = []timeFormat{
+ {
+ format: "2006-01-02-07:00",
+ precision: 24 * time.Hour,
+ // TODO: Support field annotation to change start vs end of day
+ // TODO: Support timezone context passed down to allow naked date
+ },
+ {
+ format: "2006-01-02T15:04:05Z",
+ precision: 1 * time.Second,
+ },
+ {
+ format: "2006-01-02T15:04:05-07:00",
+ precision: 1 * time.Second,
+ },
+}
+
+func parseTime(str string) (*timeVal, error) {
+ if strings.ToLower(str) == "now" {
+ return &timeVal{
+ time: time.Now(),
+ precision: 1 * time.Nanosecond,
+ }, nil
+ }
+
+ for _, format := range timeFormats {
+ tm, err := time.Parse(format.format, str)
+ if err != nil {
+ continue
+ }
+
+ return &timeVal{
+ time: tm,
+ precision: format.precision,
+ }, nil
+ }
+
+ i, err := strconv.ParseInt(str, 10, 64)
+ if err != nil {
+ return nil, jsrest.Errorf(jsrest.ErrBadRequest, "%s (%w)", str, ErrUnknownTimeFormat)
+ }
+
+ // UNIX Seconds: 2969-05-03
+ // UNIX Millis: 1971-01-01
+ // Intended to give us a wide range of useful values in both schemes
+ if i > 31536000000 {
+ return &timeVal{
+ time: time.UnixMilli(i),
+ precision: 1 * time.Millisecond,
+ }, nil
+ }
+
+ return &timeVal{
+ time: time.Unix(i, 0),
+ precision: 1 * time.Second,
+ }, nil
+}
+
+
+
package path
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "sort"
+ "strings"
+ "time"
+
+ "cloud.google.com/go/civil"
+ "github.com/gopatchy/jsrest"
+ "golang.org/x/exp/slices"
+)
+
+type WalkCallback func(string, []string, reflect.StructField)
+
+var (
+ TimeTimeType = reflect.TypeOf(time.Time{})
+ CivilDateType = reflect.TypeOf(civil.Date{})
+
+ ErrNotAStruct = errors.New("not a struct")
+ ErrUnknownFieldName = errors.New("unknown field name")
+)
+
+func Get(obj any, path string) (any, error) {
+ v, err := GetValue(reflect.ValueOf(obj), path)
+ if err != nil {
+ return nil, err
+ }
+
+ return v.Interface(), nil
+}
+
+func GetValue(v reflect.Value, path string) (reflect.Value, error) {
+ parts := strings.Split(path, ".")
+ return getRecursive(v, parts, []string{})
+}
+
+func getRecursive(v reflect.Value, parts []string, prev []string) (reflect.Value, error) {
+ if v.Kind() == reflect.Pointer {
+ if v.IsNil() {
+ v = reflect.Zero(v.Type().Elem())
+ } else {
+ v = reflect.Indirect(v)
+ }
+ }
+
+ if len(parts) == 0 {
+ return v, nil
+ }
+
+ if v.Kind() != reflect.Struct {
+ return reflect.Value{}, jsrest.Errorf(jsrest.ErrBadRequest, "%s (%w)", strings.Join(prev, "."), ErrNotAStruct)
+ }
+
+ part := parts[0]
+
+ sub, found := getField(v, part)
+ if !found {
+ return reflect.Value{}, jsrest.Errorf(jsrest.ErrBadRequest, "%s (%w)", errorPath(prev, part), ErrUnknownFieldName)
+ }
+
+ newPrev := []string{}
+ newPrev = append(newPrev, prev...)
+ newPrev = append(newPrev, part)
+
+ return getRecursive(sub, parts[1:], newPrev)
+}
+
+func getField(v reflect.Value, name string) (reflect.Value, bool) {
+ field, found := getStructField(v.Type(), name)
+ if !found {
+ return reflect.Value{}, false
+ }
+
+ return v.FieldByName(field.Name), true
+}
+
+func Set(obj any, path string, val string) error {
+ return SetValue(reflect.ValueOf(obj), path, val)
+}
+
+func SetValue(v reflect.Value, path string, val string) error {
+ parts := strings.Split(path, ".")
+ return setRecursive(v, parts, []string{}, val)
+}
+
+func setRecursive(v reflect.Value, parts []string, prev []string, val string) error {
+ if v.Kind() == reflect.Pointer {
+ if v.IsNil() {
+ v.Set(reflect.New(v.Type().Elem()))
+ }
+
+ v = reflect.Indirect(v)
+ }
+
+ if len(parts) == 0 {
+ n, err := parse(val, v.Interface())
+ if err != nil {
+ return err
+ }
+
+ if _, ok := n.(*timeVal); ok {
+ n = n.(*timeVal).time
+ }
+
+ v.Set(reflect.ValueOf(n))
+
+ return nil
+ }
+
+ if v.Kind() != reflect.Struct {
+ return jsrest.Errorf(jsrest.ErrBadRequest, "%s (%w)", strings.Join(prev, "."), ErrNotAStruct)
+ }
+
+ part := parts[0]
+
+ sub, found := getField(v, part)
+ if !found {
+ return jsrest.Errorf(jsrest.ErrBadRequest, "%s (%w)", errorPath(prev, part), ErrUnknownFieldName)
+ }
+
+ newPrev := []string{}
+ newPrev = append(newPrev, prev...)
+ newPrev = append(newPrev, part)
+
+ return setRecursive(sub, parts[1:], newPrev, val)
+}
+
+func List(obj any) []string {
+ return ListType(reflect.TypeOf(obj))
+}
+
+func ListType(t reflect.Type) []string {
+ list := []string{}
+
+ WalkType(t, func(path string, _ []string, field reflect.StructField) {
+ t := MaybeIndirectType(field.Type)
+ if t.Kind() == reflect.Struct && t != TimeTimeType && t != CivilDateType {
+ return
+ }
+
+ list = append(list, path)
+ })
+
+ sort.Strings(list)
+
+ return list
+}
+
+func GetFieldType(t reflect.Type, path string) reflect.Type {
+ parts := strings.Split(path, ".")
+
+ for _, part := range parts {
+ field, found := getStructField(MaybeIndirectType(t), part)
+ if !found {
+ return nil
+ }
+
+ t = field.Type
+ }
+
+ return t
+}
+
+func FindTagValueType(t reflect.Type, key, value string) (string, bool) {
+ ret := ""
+
+ WalkType(t, func(path string, _ []string, field reflect.StructField) {
+ tag, found := field.Tag.Lookup(key)
+ if !found {
+ return
+ }
+
+ parts := strings.Split(tag, ",")
+
+ if slices.Contains(parts, value) {
+ ret = path
+ }
+ })
+
+ return ret, ret != ""
+}
+
+func Walk(obj any, cb WalkCallback) {
+ WalkType(reflect.TypeOf(obj), cb)
+}
+
+func WalkType(t reflect.Type, cb WalkCallback) {
+ walkRecursive(MaybeIndirectType(t), cb, []string{})
+}
+
+func walkRecursive(t reflect.Type, cb WalkCallback, prev []string) {
+ for i := 0; i < t.NumField(); i++ {
+ sub := t.Field(i)
+
+ newPrev := []string{}
+ newPrev = append(newPrev, prev...)
+
+ if !sub.Anonymous {
+ newPrev = append(newPrev, FieldName(sub))
+ }
+
+ t := MaybeIndirectType(sub.Type)
+
+ if len(newPrev) > 0 {
+ cb(strings.Join(newPrev, "."), newPrev, sub)
+ }
+
+ if t.Kind() == reflect.Struct && t != TimeTimeType && t != CivilDateType {
+ walkRecursive(t, cb, newPrev)
+ }
+ }
+}
+
+func getStructField(t reflect.Type, name string) (reflect.StructField, bool) {
+ name = strings.ToLower(name)
+
+ return t.FieldByNameFunc(func(iterName string) bool {
+ iterField, iterOK := t.FieldByName(iterName)
+ if !iterOK {
+ panic(iterName)
+ }
+
+ return strings.ToLower(FieldName(iterField)) == name
+ })
+}
+
+func errorPath(prev []string, part string) string {
+ if len(prev) == 0 {
+ return part
+ }
+
+ return fmt.Sprintf("%s.%s", strings.Join(prev, "."), part)
+}
+
+func FieldName(field reflect.StructField) string {
+ tag := field.Tag.Get("json")
+ if tag != "" {
+ if tag == "-" {
+ return ""
+ }
+
+ parts := strings.SplitN(tag, ",", 2)
+
+ return parts[0]
+ }
+
+ return field.Name
+}
+
+func MaybeIndirectType(t reflect.Type) reflect.Type {
+ if t.Kind() == reflect.Pointer {
+ return t.Elem()
+ }
+
+ return t
+}
+
+
+
package path
+
+import "reflect"
+
+func isSlice(v any) bool {
+ return reflect.TypeOf(v).Kind() == reflect.Slice
+}
+
+func anyTrue(v any, cb func(any, int) bool) bool {
+ val := reflect.ValueOf(v)
+
+ for i := 0; i < val.Len(); i++ {
+ sub := val.Index(i)
+
+ if sub.Kind() == reflect.Pointer && sub.IsNil() {
+ continue
+ }
+
+ sub = reflect.Indirect(sub)
+
+ if cb(sub.Interface(), i) {
+ return true
+ }
+ }
+
+ return false
+}
+
+
+
package path
+
+import (
+ "errors"
+ "reflect"
+ "sort"
+ "time"
+
+ "cloud.google.com/go/civil"
+ "github.com/gopatchy/jsrest"
+)
+
+func Sort(objs any, path string) error {
+ as := newAnySlice(objs, path)
+ sort.Stable(as)
+
+ return as.err
+}
+
+func SortReverse(objs any, path string) error {
+ as := newAnySlice(objs, path)
+ sort.Stable(sort.Reverse(as))
+
+ return as.err
+}
+
+type anySlice struct {
+ path string
+ slice reflect.Value
+ swapper func(i, j int)
+ err error
+}
+
+var ErrUnsupportedSortType = errors.New("unsupported _sort type")
+
+func newAnySlice(objs any, path string) *anySlice {
+ return &anySlice{
+ path: path,
+ slice: reflect.ValueOf(objs),
+ swapper: reflect.Swapper(objs),
+ }
+}
+
+func (as *anySlice) Len() int {
+ return as.slice.Len()
+}
+
+func (as *anySlice) Less(i, j int) bool {
+ v1, err := Get(as.slice.Index(i).Interface(), as.path)
+ if err != nil {
+ as.err = err
+ // We have to obey the Less() contract even in error cases
+ return i < j
+ }
+
+ v2, err := Get(as.slice.Index(j).Interface(), as.path)
+ if err != nil {
+ as.err = err
+ return i < j
+ }
+
+ switch {
+ case v1 == nil && v2 == nil:
+ return false
+ case v1 == nil:
+ return true
+ case v2 == nil:
+ return false
+ }
+
+ switch t1 := v1.(type) {
+ case int:
+ return t1 < v2.(int)
+
+ case int64:
+ return t1 < v2.(int64)
+
+ case uint:
+ return t1 < v2.(uint)
+
+ case uint64:
+ return t1 < v2.(uint64)
+
+ case float32:
+ return t1 < v2.(float32)
+
+ case float64:
+ return t1 < v2.(float64)
+
+ case string:
+ return t1 < v2.(string)
+
+ case bool:
+ return !t1 && v2.(bool)
+
+ case time.Time:
+ return t1.Before(v2.(time.Time))
+
+ case civil.Date:
+ return t1.Before(v2.(civil.Date))
+
+ default:
+ as.err = jsrest.Errorf(jsrest.ErrBadRequest, "%s: %T (%w)", as.path, t1, ErrUnsupportedSortType)
+ return i < j
+ }
+}
+
+func (as *anySlice) Swap(i, j int) {
+ as.swapper(i, j)
+}
+
+
+