serializer factory + rm unpublicly content

Author: DarkMiMolle

thrift/sql/serializing.go

@@ -10,14 +10,8 @@ import (
 	"github.com/upfluence/pkg/thrift/thriftutil"
 )
 
-var (
-	binaryThriftSerializer = serializer.NewTSerializer(
-		thriftutil.BinaryProtocolFactory,
-	)
-
-	binaryThriftDeserializer = serializer.NewTDeserializer(
-		thriftutil.BinaryProtocolFactory,
-	)
+var defaultSerializerFactory = serializer.NewTSerializerFactory(
+	thriftutil.BinaryProtocolFactory,
 )
 
 type TStructPtr[T any] interface {
@@ -26,7 +20,16 @@ type TStructPtr[T any] interface {
 }
 
 type NullThrift[T any, PT TStructPtr[T]] struct {
-	Data PT
+	Data              PT
+	SerializerFactory *serializer.TSerializerFactory
+}
+
+func (t NullThrift[T, PT]) serializerFactory() *serializer.TSerializerFactory {
+	if t.SerializerFactory == nil {
+		return defaultSerializerFactory
+	}
+
+	return t.SerializerFactory
 }
 
 func (t *NullThrift[T, PT]) Scan(value any) error {
@@ -46,15 +49,17 @@ func (t *NullThrift[T, PT]) Scan(value any) error {
 		t.Data = new(T)
 	}
 
-	return errors.WithStack(binaryThriftDeserializer.Read(t.Data, data))
+	return errors.WithStack(
+		t.serializerFactory().GetDeserializer().Read(t.Data, data),
+	)
 }
 
 func (t NullThrift[T, PT]) Value() (driver.Value, error) {
 	if t.Data == nil {
 		return nil, nil // nolint:nilnil
 	}
 
-	data, err := binaryThriftSerializer.Write(t.Data)
+	data, err := t.serializerFactory().GetSerializer().Write(t.Data)
 
 	return data, errors.WithStack(err)
 }

thrift/sql/serializing_test.go

@@ -1,37 +1,76 @@
 package sql
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"github.com/upfluence/base/provider/credential"
+	"github.com/upfluence/errors"
+	"github.com/upfluence/thrift/lib/go/thrift"
+
+	"github.com/upfluence/pkg/thrift/serializer"
+	"github.com/upfluence/pkg/thrift/thriftutil"
 )
 
-func TestNullableThrift(t *testing.T) {
+type fakeTStruct struct {
+	value int64
+}
+
+func (t fakeTStruct) Write(p thrift.TProtocol) error {
+	return errors.WithStack(p.WriteI64(t.value))
+}
+
+func (t *fakeTStruct) Read(p thrift.TProtocol) error {
+	val, err := p.ReadI64()
+
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	t.value = val
+
+	return nil
+}
+
+func (t *fakeTStruct) String() string {
+	return fmt.Sprint(t.value)
+}
+
+func TestNullableThrift_Scan(t *testing.T) {
 	for _, tt := range []struct {
-		name      string
-		wantValue *credential.CredentialReference
+		name              string
+		fakeValue         *fakeTStruct
+		serializerFactory *serializer.TSerializerFactory
 	}{
 		{
 			name:      "nil value",
-			wantValue: nil,
+			fakeValue: nil,
 		},
 		{
 			name: "with value",
-			wantValue: &credential.CredentialReference{
-				Type: credential.CredentialType_StripeConnectedAccount,
-				Id:   42,
+			fakeValue: &fakeTStruct{
+				value: 42,
+			},
+		},
+		{
+			name: "with custom serializer factory",
+			fakeValue: &fakeTStruct{
+				value: 42,
 			},
+			serializerFactory: serializer.NewTSerializerFactory(
+				thriftutil.JSONProtocolFactory,
+			),
 		},
 	} {
 		t.Run(tt.name, func(t *testing.T) {
 			var (
 				s = NullThrift[
-					credential.CredentialReference,
-					*credential.CredentialReference,
+					fakeTStruct,
+					*fakeTStruct,
 				]{
-					Data: tt.wantValue,
+					Data:              tt.fakeValue,
+					SerializerFactory: tt.serializerFactory,
 				}
 
 				data, err = s.Value()
@@ -42,7 +81,7 @@ func TestNullableThrift(t *testing.T) {
 			s.Data = nil
 
 			require.NoError(t, s.Scan(data))
-			assert.Equal(t, tt.wantValue, s.Data)
+			assert.Equal(t, tt.fakeValue, s.Data)
 		})
 	}
 }