Merge pull request #33 from upfluence/sp/json-type

Add serialyser in JSON

Author: Sypheos

.github/workflows/ci.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ubuntu-20.04
     strategy:
       matrix:
-        go: [ '1.16.x', '1.15.x', '1.14.x' ]
+        go: [ '1.18.x', '1.17.x', '1.16.x' ]
     services:
       postgres:
         image: postgres

.github/workflows/lint.yml

@@ -10,7 +10,7 @@ jobs:
       - name: Install Go
         uses: actions/setup-go@v2
         with:
-          go-version: 1.16.x
+          go-version: 1.18.x
       - name: Check out code
         uses: actions/checkout@v1
       - name: golanci-lint

go.mod

@@ -1,6 +1,6 @@
 module github.com/upfluence/sql
 
-go 1.16
+go 1.18
 
 require (
 	github.com/lib/pq v1.4.0
@@ -9,3 +9,9 @@ require (
 	github.com/upfluence/errors v0.2.2
 	github.com/upfluence/log v0.0.4
 )
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	gopkg.in/yaml.v3 v3.0.0-20200605160147-a5ece683394c // indirect
+)

sqltypes/json.go

@@ -0,0 +1,45 @@
+package sqltypes
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+
+	"github.com/upfluence/errors"
+)
+
+type JSONValue struct {
+	Data  interface{}
+	Valid bool
+}
+
+func (jv *JSONValue) Scan(v interface{}) error {
+	var err error
+
+	jv.Valid = false
+
+	switch vv := v.(type) {
+	case nil:
+		return nil
+	case []byte:
+		err = json.Unmarshal(vv, &jv.Data)
+	case string:
+		err = json.Unmarshal([]byte(vv), &jv.Data)
+	default:
+		err = errors.Wrap(errInvalidType, "expecting a byte slice or string")
+	}
+
+	if err != nil {
+		return err
+	}
+
+	jv.Valid = true
+	return nil
+}
+
+func (jv JSONValue) Value() (driver.Value, error) {
+	if !jv.Valid {
+		return nil, nil
+	}
+
+	return json.Marshal(jv.Data)
+}

sqltypes/json_test.go

@@ -0,0 +1,158 @@
+package sqltypes
+
+import (
+	"database/sql"
+	"database/sql/driver"
+	"encoding/json"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/upfluence/errors/errtest"
+)
+
+type testPayload struct {
+	Key string `json:"key"`
+}
+
+func TestScan(t *testing.T) {
+	for _, tt := range []struct {
+		name string
+
+		value   interface{}
+		want    JSONValue
+		wantErr errtest.ErrorAssertion
+	}{
+		{
+			name:    "wrong value type",
+			value:   1,
+			want:    JSONValue{Data: &testPayload{}},
+			wantErr: errtest.ErrorCause(errInvalidType),
+		},
+		{
+			name:  "invalid json",
+			value: "test",
+			want:  JSONValue{Data: &testPayload{}},
+			wantErr: errtest.ErrorAssertionFunc(
+				func(tb testing.TB, err error) {
+					assert.IsType(t, &json.SyntaxError{}, err)
+				},
+			),
+		},
+		{
+			name:    "nil",
+			want:    JSONValue{Data: &testPayload{}},
+			wantErr: errtest.NoError(),
+		},
+		{
+			name:    "success",
+			value:   `{"key":"foo"}`,
+			want:    JSONValue{Data: &testPayload{Key: "foo"}, Valid: true},
+			wantErr: errtest.NoError(),
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			var jv = JSONValue{Data: &testPayload{}}
+
+			err := jv.Scan(tt.value)
+			tt.wantErr.Assert(t, err)
+			assert.Equal(t, tt.want, jv)
+		})
+	}
+}
+
+func TestShadowScan(t *testing.T) {
+	for _, tt := range []struct {
+		name string
+
+		scanner sql.Scanner
+		value   interface{}
+		want    interface{}
+	}{
+		{
+			name: "override object",
+			scanner: &JSONValue{
+				Data: &testPayload{Key: "foo"},
+			},
+			value: `{"key":"bar"}`,
+			want: &JSONValue{
+				Data:  &testPayload{Key: "bar"},
+				Valid: true,
+			},
+		},
+		{
+			name: "override object with nil becomes invalid",
+			scanner: &JSONValue{
+				Data:  &testPayload{Key: "foo"},
+				Valid: true,
+			},
+			want: &JSONValue{
+				Data: &testPayload{Key: "foo"},
+			},
+		},
+		{
+			name: "override map with nil becomes invalid",
+			scanner: &JSONValue{
+				Data: map[string]interface{}{"foo": 1},
+			},
+			want: &JSONValue{
+				Data:  map[string]interface{}{"foo": 1},
+				Valid: false,
+			},
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			err := tt.scanner.Scan(tt.value)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want, tt.scanner)
+		})
+	}
+}
+
+func TestValue(t *testing.T) {
+	for _, tt := range []struct {
+		name string
+
+		value   driver.Valuer
+		want    interface{}
+		wantErr error
+	}{
+		{
+			name: "invalid data",
+			value: JSONValue{
+				Data: testPayload{},
+			},
+		},
+		{
+			name: "string",
+			value: JSONValue{
+				Data:  "test",
+				Valid: true,
+			},
+			want: []byte(`"test"`),
+		},
+		{
+			name: "number",
+			value: JSONValue{
+				Data:  1,
+				Valid: true,
+			},
+			want: []byte(`1`),
+		},
+		{
+			name: "object",
+			value: JSONValue{
+				Data: testPayload{
+					Key: "foo",
+				},
+				Valid: true,
+			},
+			want: []byte(`{"key":"foo"}`),
+		},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			v, err := tt.value.Value()
+			assert.Equal(t, tt.wantErr, err)
+			assert.Equal(t, tt.want, v)
+		})
+	}
+}