feat: Add blob scalar type

client/descriptions.go

@@ -166,7 +166,7 @@ const (
 	FieldKind_DATETIME     FieldKind = 10
 	FieldKind_STRING       FieldKind = 11
 	FieldKind_STRING_ARRAY FieldKind = 12
-	_                      FieldKind = 13 // safe to repurpose (was never used)
+	FieldKind_BYTES        FieldKind = 13
 	_                      FieldKind = 14 // safe to repurpose (was never used)
 	_                      FieldKind = 15 // safe to repurpose (was never used)
 
@@ -204,6 +204,7 @@ var FieldKindStringToEnumMapping = map[string]FieldKind{
 	"String":     FieldKind_STRING,
 	"[String]":   FieldKind_NILLABLE_STRING_ARRAY,
 	"[String!]":  FieldKind_STRING_ARRAY,
+	"Bytes":      FieldKind_BYTES,
 }
 
 // RelationType describes the type of relation between two types.

db/collection_update.go

@@ -470,6 +470,9 @@ func validateFieldSchema(val *fastjson.Value, field client.FieldDescription) (an
 
 	case client.FieldKind_FOREIGN_OBJECT, client.FieldKind_FOREIGN_OBJECT_ARRAY:
 		return nil, NewErrFieldOrAliasToFieldNotExist(field.Name)
+
+	case client.FieldKind_BYTES:
+		return getString(val)
 	}
 
 	return nil, client.NewErrUnhandledType("FieldKind", field.Kind)

request/graphql/schema/collection.go

@@ -331,6 +331,7 @@ func astTypeToKind(t ast.Type) (client.FieldKind, error) {
 		typeFloat    string = "Float"
 		typeDateTime string = "DateTime"
 		typeString   string = "String"
+		typeBytes    string = "Bytes"
 	)
 
 	switch astTypeVal := t.(type) {
@@ -379,6 +380,8 @@ func astTypeToKind(t ast.Type) (client.FieldKind, error) {
 			return client.FieldKind_DATETIME, nil
 		case typeString:
 			return client.FieldKind_STRING, nil
+		case typeBytes:
+			return client.FieldKind_BYTES, nil
 		default:
 			return client.FieldKind_FOREIGN_OBJECT, nil
 		}

request/graphql/schema/descriptions.go

@@ -14,6 +14,7 @@ import (
 	gql "github.com/sourcenetwork/graphql-go"
 
 	"github.com/sourcenetwork/defradb/client"
+	schemaTypes "github.com/sourcenetwork/defradb/request/graphql/schema/types"
 )
 
 var (
@@ -31,9 +32,10 @@ var (
 		gql.String:    client.FieldKind_STRING,
 		&gql.Object{}: client.FieldKind_FOREIGN_OBJECT,
 		&gql.List{}:   client.FieldKind_FOREIGN_OBJECT_ARRAY,
+		// Custom scalars
+		schemaTypes.BytesScalarType: client.FieldKind_BYTES,
 		// More custom ones to come
 		// - JSON
-		// - ByteArray
 		// - Counters
 	}
 
@@ -52,6 +54,7 @@ var (
 		client.FieldKind_STRING:                gql.String,
 		client.FieldKind_STRING_ARRAY:          gql.NewList(gql.NewNonNull(gql.String)),
 		client.FieldKind_NILLABLE_STRING_ARRAY: gql.NewList(gql.String),
+		client.FieldKind_BYTES:                 schemaTypes.BytesScalarType,
 	}
 
 	// This map is fine to use
@@ -70,6 +73,7 @@ var (
 		client.FieldKind_STRING:                client.LWW_REGISTER,
 		client.FieldKind_STRING_ARRAY:          client.LWW_REGISTER,
 		client.FieldKind_NILLABLE_STRING_ARRAY: client.LWW_REGISTER,
+		client.FieldKind_BYTES:                 client.LWW_REGISTER,
 		client.FieldKind_FOREIGN_OBJECT:        client.NONE_CRDT,
 		client.FieldKind_FOREIGN_OBJECT_ARRAY:  client.NONE_CRDT,
 	}

request/graphql/schema/manager.go

@@ -141,6 +141,9 @@ func defaultTypes() []gql.Type {
 		gql.Int,
 		gql.String,
 
+		// Custom Scalar types
+		schemaTypes.BytesScalarType,
+
 		// Base Query types
 
 		// Sort/Order enum

request/graphql/schema/types/scalars.go

@@ -0,0 +1,63 @@
+// Copyright 2023 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package types
+
+import (
+	"encoding/hex"
+
+	"github.com/sourcenetwork/graphql-go"
+	"github.com/sourcenetwork/graphql-go/language/ast"
+)
+
+var BytesScalarType = graphql.NewScalar(graphql.ScalarConfig{
+	Name:        "Bytes",
+	Description: "The `Bytes` scalar type represents an array of bytes.",
+	Serialize: func(value any) any {
+		switch value := value.(type) {
+		case []byte:
+			return hex.EncodeToString(value)
+		case *[]byte:
+			return hex.EncodeToString(*value)
+		default:
+			return nil
+		}
+	},
+	ParseValue: func(value any) any {
+		switch value := value.(type) {
+		case string:
+			data, err := hex.DecodeString(value)
+			if err != nil {
+				return nil
+			}
+			return data
+		case *string:
+			data, err := hex.DecodeString(*value)
+			if err != nil {
+				return nil
+			}
+			return data
+		default:
+			return nil
+		}
+	},
+	ParseLiteral: func(valueAST ast.Value) any {
+		switch valueAST := valueAST.(type) {
+		case *ast.StringValue:
+			data, err := hex.DecodeString(valueAST.Value)
+			if err != nil {
+				return nil
+			}
+			return data
+		default:
+			return nil
+		}
+	},
+})

request/graphql/schema/types/scalars_test.go

@@ -0,0 +1,82 @@
+// Copyright 2023 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package types
+
+import (
+	"testing"
+
+	"github.com/sourcenetwork/graphql-go/language/ast"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBytesScalarTypeSerialize(t *testing.T) {
+	input := []byte{0, 255}
+	output := "00ff"
+
+	cases := []struct {
+		input  any
+		expect any
+	}{
+		{input, output},
+		{&input, output},
+		{nil, nil},
+		{0, nil},
+		{false, nil},
+	}
+	for _, c := range cases {
+		result := BytesScalarType.Serialize(c.input)
+		assert.Equal(t, c.expect, result)
+	}
+}
+
+func TestBytesScalarTypeParseValue(t *testing.T) {
+	input := "00ff"
+	output := []byte{0, 255}
+	invalid := "invalid"
+
+	cases := []struct {
+		input  any
+		expect any
+	}{
+		{input, output},
+		{&input, output},
+		{invalid, nil},
+		{&invalid, nil},
+		{nil, nil},
+		{0, nil},
+		{false, nil},
+	}
+	for _, c := range cases {
+		result := BytesScalarType.ParseValue(c.input)
+		assert.Equal(t, c.expect, result)
+	}
+}
+
+func TestBytesScalarTypeParseLiteral(t *testing.T) {
+	cases := []struct {
+		input  ast.Value
+		expect any
+	}{
+		{&ast.StringValue{Value: "00ff"}, []byte{0, 255}},
+		{&ast.StringValue{Value: "invalid"}, nil},
+		{&ast.IntValue{}, nil},
+		{&ast.BooleanValue{}, nil},
+		{&ast.NullValue{}, nil},
+		{&ast.EnumValue{}, nil},
+		{&ast.FloatValue{}, nil},
+		{&ast.ListValue{}, nil},
+		{&ast.ObjectValue{}, nil},
+	}
+	for _, c := range cases {
+		result := BytesScalarType.ParseLiteral(c.input)
+		assert.Equal(t, c.expect, result)
+	}
+}

tests/integration/mutation/update/field_kinds/bytes_test.go

@@ -0,0 +1,60 @@
+// Copyright 2023 Democratized Data Foundation
+//
+// Use of this software is governed by the Business Source License
+// included in the file licenses/BSL.txt.
+//
+// As of the Change Date specified in that file, in accordance with
+// the Business Source License, use of this software will be governed
+// by the Apache License, Version 2.0, included in the file
+// licenses/APL.txt.
+
+package field_kinds
+
+import (
+	"testing"
+
+	testUtils "github.com/sourcenetwork/defradb/tests/integration"
+)
+
+func TestMutationUpdate_WithBytesField(t *testing.T) {
+	test := testUtils.TestCase{
+		Description: "Simple update of bytes field",
+		Actions: []any{
+			testUtils.SchemaUpdate{
+				Schema: `
+					type Users {
+						name: String
+						data: Bytes
+					}
+				`,
+			},
+			testUtils.CreateDoc{
+				Doc: `{
+					"name": "John",
+					"data": "00FE"
+				}`,
+			},
+			testUtils.UpdateDoc{
+				Doc: `{
+					"data": "00FF"
+				}`,
+			},
+			testUtils.Request{
+				Request: `
+					query {
+						Users {
+							data
+						}
+					}
+				`,
+				Results: []map[string]any{
+					{
+						"data": "00FF",
+					},
+				},
+			},
+		},
+	}
+
+	testUtils.ExecuteTestCase(t, test)
+}

tests/integration/schema/simple_test.go

@@ -271,3 +271,49 @@ func TestSchemaSimpleErrorsGivenNonNullManyRelationField(t *testing.T) {
 
 	testUtils.ExecuteTestCase(t, test)
 }
+
+func TestSchemaSimpleCreatesSchemaGivenTypeWithBytesField(t *testing.T) {
+	test := testUtils.TestCase{
+		Actions: []any{
+			testUtils.SchemaUpdate{
+				Schema: `
+					type Users {
+						data: Bytes
+					}
+				`,
+			},
+			testUtils.IntrospectionRequest{
+				Request: `
+					query {
+						__type (name: "Users") {
+							name
+							fields {
+								name
+								type {
+								name
+								kind
+								}
+							}
+						}
+					}
+				`,
+				ExpectedData: map[string]any{
+					"__type": map[string]any{
+						"name": "Users",
+						"fields": DefaultFields.Append(
+							Field{
+								"name": "data",
+								"type": map[string]any{
+									"kind": "SCALAR",
+									"name": "Bytes",
+								},
+							},
+						).Tidy(),
+					},
+				},
+			},
+		},
+	}
+
+	testUtils.ExecuteTestCase(t, test)
+}

tests/integration/schema/updates/add/field/kind/invalid_test.go

@@ -64,30 +64,6 @@ func TestSchemaUpdatesAddFieldKind9(t *testing.T) {
 	testUtils.ExecuteTestCase(t, test)
 }
 
-func TestSchemaUpdatesAddFieldKind13(t *testing.T) {
-	test := testUtils.TestCase{
-		Description: "Test schema update, add field with kind deprecated (13)",
-		Actions: []any{
-			testUtils.SchemaUpdate{
-				Schema: `
-					type Users {
-						name: String
-					}
-				`,
-			},
-			testUtils.SchemaPatch{
-				Patch: `
-					[
-						{ "op": "add", "path": "/Users/Fields/-", "value": {"Name": "foo", "Kind": 13} }
-					]
-				`,
-				ExpectedError: "no type found for given name. Type: 13",
-			},
-		},
-	}
-	testUtils.ExecuteTestCase(t, test)
-}
-
 func TestSchemaUpdatesAddFieldKind14(t *testing.T) {
 	test := testUtils.TestCase{
 		Description: "Test schema update, add field with kind deprecated (14)",