feat: Add DateTime custom scalars (#931)

Adds support for DateTime custom scalar types in schemas and filter query arguments. At the moment this doesn't support NonNull DateTimes yet.
sourcenetwork · Nov 19, 2022 · 82e0d2f · 82e0d2f
1 parent 4b14839
commit 82e0d2f
Show file tree

Hide file tree

Showing 47 changed files with 1,600 additions and 189 deletions.
diff --git a/client/descriptions.go b/client/descriptions.go
@@ -133,8 +133,8 @@ const (
 	FieldKind_FLOAT        FieldKind = 6
 	FieldKind_FLOAT_ARRAY  FieldKind = 7
 	FieldKind_DECIMAL      FieldKind = 8
-	FieldKind_DATE         FieldKind = 9
-	FieldKind_TIMESTAMP    FieldKind = 10
+	_                      FieldKind = 9 // safe to repurpose (previoulsy old field)
+	FieldKind_DATETIME     FieldKind = 10
 	FieldKind_STRING       FieldKind = 11
 	FieldKind_STRING_ARRAY FieldKind = 12
 	FieldKind_BYTES        FieldKind = 13

diff --git a/connor/eq.go b/connor/eq.go
@@ -2,9 +2,11 @@ package connor
 
 import (
 	"reflect"
+	"time"
 
 	"github.com/sourcenetwork/defradb/client"
 	"github.com/sourcenetwork/defradb/connor/numbers"
+	ctime "github.com/sourcenetwork/defradb/connor/time"
 	"github.com/sourcenetwork/defradb/core"
 )
 
@@ -58,6 +60,8 @@ func eq(condition, data any) (bool, error) {
 		return false, nil
 	case int64:
 		return numbers.Equal(cn, data), nil
+	case int:
+		return numbers.Equal(cn, data), nil
 	case float64:
 		return numbers.Equal(cn, data), nil
 	case map[FilterKey]any:
@@ -76,6 +80,8 @@ func eq(condition, data any) (bool, error) {
 		}
 
 		return m, nil
+	case time.Time:
+		return ctime.Equal(cn, data), nil
 	default:
 		return reflect.DeepEqual(condition, data), nil
 	}

diff --git a/connor/ge.go b/connor/ge.go
@@ -2,6 +2,7 @@ package connor
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/sourcenetwork/defradb/connor/numbers"
 	"github.com/sourcenetwork/defradb/errors"
@@ -15,26 +16,42 @@ func ge(condition, data any) (bool, error) {
 		return true, nil
 	}
 
-	switch cn := numbers.TryUpcast(condition).(type) {
-	case float64:
-		switch dn := numbers.TryUpcast(data).(type) {
-		case float64:
-			return dn >= cn, nil
-		case int64:
-			return float64(dn) > cn, nil
+	switch c := condition.(type) {
+	case time.Time:
+		switch d := data.(type) {
+		case time.Time:
+			return d.After(c) || d.Equal(c), nil
+		case string:
+			dt, err := time.Parse(time.RFC3339, d)
+			if err != nil {
+				return false, err
+			}
+			return dt.After(c) || dt.Equal(c), nil
+		default:
+			return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
 		}
-
-		return false, nil
-	case int64:
-		switch dn := numbers.TryUpcast(data).(type) {
+	default:
+		switch cn := numbers.TryUpcast(condition).(type) {
 		case float64:
-			return dn >= float64(cn), nil
+			switch dn := numbers.TryUpcast(data).(type) {
+			case float64:
+				return dn >= cn, nil
+			case int64:
+				return float64(dn) > cn, nil
+			}
+
+			return false, nil
 		case int64:
-			return dn >= cn, nil
-		}
+			switch dn := numbers.TryUpcast(data).(type) {
+			case float64:
+				return dn >= float64(cn), nil
+			case int64:
+				return dn >= cn, nil
+			}
 
-		return false, nil
-	default:
-		return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
+			return false, nil
+		default:
+			return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
+		}
 	}
 }
diff --git a/connor/gt.go b/connor/gt.go
@@ -2,6 +2,7 @@ package connor
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/sourcenetwork/defradb/connor/numbers"
 	"github.com/sourcenetwork/defradb/errors"
@@ -14,26 +15,42 @@ func gt(condition, data any) (bool, error) {
 		return data != nil, nil
 	}
 
-	switch cn := numbers.TryUpcast(condition).(type) {
-	case float64:
-		switch dn := numbers.TryUpcast(data).(type) {
-		case float64:
-			return dn > cn, nil
-		case int64:
-			return float64(dn) > cn, nil
+	switch c := condition.(type) {
+	case time.Time:
+		switch d := data.(type) {
+		case time.Time:
+			return d.After(c), nil
+		case string:
+			dt, err := time.Parse(time.RFC3339, d)
+			if err != nil {
+				return false, err
+			}
+			return dt.After(c), nil
+		default:
+			return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
 		}
-
-		return false, nil
-	case int64:
-		switch dn := numbers.TryUpcast(data).(type) {
+	default:
+		switch cn := numbers.TryUpcast(condition).(type) {
 		case float64:
-			return dn > float64(cn), nil
+			switch dn := numbers.TryUpcast(data).(type) {
+			case float64:
+				return dn > cn, nil
+			case int64:
+				return float64(dn) > cn, nil
+			}
+
+			return false, nil
 		case int64:
-			return dn > cn, nil
-		}
+			switch dn := numbers.TryUpcast(data).(type) {
+			case float64:
+				return dn > float64(cn), nil
+			case int64:
+				return dn > cn, nil
+			}
 
-		return false, nil
-	default:
-		return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
+			return false, nil
+		default:
+			return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
+		}
 	}
 }
diff --git a/connor/in.go b/connor/in.go
@@ -1,6 +1,8 @@
 package connor
 
-import "github.com/sourcenetwork/defradb/errors"
+import (
+	"github.com/sourcenetwork/defradb/errors"
+)
 
 // in will determine whether a value exists within the
 // condition's array of available values.

diff --git a/connor/le.go b/connor/le.go
@@ -2,6 +2,7 @@ package connor
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/sourcenetwork/defradb/connor/numbers"
 	"github.com/sourcenetwork/defradb/errors"
@@ -15,26 +16,42 @@ func le(condition, data any) (bool, error) {
 		return data == nil, nil
 	}
 
-	switch cn := numbers.TryUpcast(condition).(type) {
-	case float64:
-		switch dn := numbers.TryUpcast(data).(type) {
-		case float64:
-			return dn <= cn, nil
-		case int64:
-			return float64(dn) <= cn, nil
+	switch c := condition.(type) {
+	case time.Time:
+		switch d := data.(type) {
+		case time.Time:
+			return d.Before(c) || d.Equal(c), nil
+		case string:
+			dt, err := time.Parse(time.RFC3339, d)
+			if err != nil {
+				return false, err
+			}
+			return dt.Before(c) || dt.Equal(c), nil
+		default:
+			return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
 		}
-
-		return false, nil
-	case int64:
-		switch dn := numbers.TryUpcast(data).(type) {
+	default:
+		switch cn := numbers.TryUpcast(condition).(type) {
 		case float64:
-			return dn <= float64(cn), nil
+			switch dn := numbers.TryUpcast(data).(type) {
+			case float64:
+				return dn <= cn, nil
+			case int64:
+				return float64(dn) <= cn, nil
+			}
+
+			return false, nil
 		case int64:
-			return dn <= cn, nil
-		}
+			switch dn := numbers.TryUpcast(data).(type) {
+			case float64:
+				return dn <= float64(cn), nil
+			case int64:
+				return dn <= cn, nil
+			}
 
-		return false, nil
-	default:
-		return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
+			return false, nil
+		default:
+			return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
+		}
 	}
 }
diff --git a/connor/lt.go b/connor/lt.go
@@ -2,6 +2,7 @@ package connor
 
 import (
 	"fmt"
+	"time"
 
 	"github.com/sourcenetwork/defradb/connor/numbers"
 	"github.com/sourcenetwork/defradb/errors"
@@ -15,26 +16,42 @@ func lt(condition, data any) (bool, error) {
 		return false, nil
 	}
 
-	switch cn := numbers.TryUpcast(condition).(type) {
-	case float64:
-		switch dn := numbers.TryUpcast(data).(type) {
-		case float64:
-			return dn < cn, nil
-		case int64:
-			return float64(dn) < cn, nil
+	switch c := condition.(type) {
+	case time.Time:
+		switch d := data.(type) {
+		case time.Time:
+			return d.Before(c), nil
+		case string:
+			dt, err := time.Parse(time.RFC3339, d)
+			if err != nil {
+				return false, err
+			}
+			return dt.Before(c), nil
+		default:
+			return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
 		}
-
-		return false, nil
-	case int64:
-		switch dn := numbers.TryUpcast(data).(type) {
+	default:
+		switch cn := numbers.TryUpcast(condition).(type) {
 		case float64:
-			return dn < float64(cn), nil
+			switch dn := numbers.TryUpcast(data).(type) {
+			case float64:
+				return dn < cn, nil
+			case int64:
+				return float64(dn) < cn, nil
+			}
+
+			return false, nil
 		case int64:
-			return dn < cn, nil
-		}
+			switch dn := numbers.TryUpcast(data).(type) {
+			case float64:
+				return dn < float64(cn), nil
+			case int64:
+				return dn < cn, nil
+			}
 
-		return false, nil
-	default:
-		return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
+			return false, nil
+		default:
+			return false, errors.New(fmt.Sprintf("unknown comparison type '%#v'", condition))
+		}
 	}
 }
diff --git a/connor/time/equality.go b/connor/time/equality.go
@@ -0,0 +1,29 @@
+package time
+
+import "time"
+
+func Equal(condition, data any) bool {
+	switch c := condition.(type) {
+	case time.Time:
+		switch d := data.(type) {
+		case time.Time:
+			return d.Equal(c)
+		case string:
+			// todo: Not sure if we should be
+			// parsing incoming data here, or
+			// if the DB should handle this.
+			// (Note: This isnt the user provided
+			// condition on a query, but the data
+			// stored in DB for a document
+			dt, err := time.Parse(time.RFC3339, d)
+			if err != nil {
+				return false
+			}
+			return dt.Equal(c)
+		default:
+			return false
+		}
+	default:
+		return false
+	}
+}
diff --git a/core/parser.go b/core/parser.go
@@ -39,6 +39,9 @@ type Parser interface {
 	// Parses the given request, returning a strongly typed model of that request.
 	Parse(request string) (*request.Request, []error)
 
+	// NewFilterFromString creates a new filter from a string.
+	NewFilterFromString(collectionType string, body string) (client.Option[request.Filter], error)
+
 	// Adds the given schema to this parser's model.
 	AddSchema(ctx context.Context, schema string) error
 }