Rename serializers to modifiers

attr_modifiers.go

@@ -0,0 +1,66 @@
+package ksql
+
+import (
+	"context"
+	"database/sql/driver"
+	"fmt"
+)
+
+// Here we keep all the registered modifier
+var modifiers = map[string]AttrModifier{
+	"json": jsonModifier{},
+}
+
+// RegisterAttrModifier allow users to add custom modifiers on startup
+// it is recommended to do this inside an init() function.
+func RegisterAttrModifier(key string, modifier AttrModifier) {
+	_, found := modifiers[key]
+	if found {
+		panic(fmt.Errorf("KSQL: cannot register modifier '%s' name is already in use", key))
+	}
+
+	modifiers[key] = modifier
+}
+
+// AttrModifier describes the two operations required to serialize and deserialize an object from the database.
+type AttrModifier interface {
+	AttrScan(ctx context.Context, opInfo OpInfo, attrPtr interface{}, dbValue interface{}) error
+	AttrValue(ctx context.Context, opInfo OpInfo, inputValue interface{}) (outputValue interface{}, _ error)
+}
+
+// OpInfo contains information that might be used by a modifier to determine how it should behave.
+type OpInfo struct {
+	// A string version of the name of one of
+	// the methods of the `ksql.Provider` interface, e.g. `Insert` or `Query`
+	Method string
+
+	// The string representing the current underlying database, e.g.:
+	// "postgres", "sqlite3", "mysql" or "sqlserver".
+	DriverName string
+}
+
+// attrModifier is the wrapper that allow us to intercept the Scan and Value processes
+// so we can run the modifiers instead of allowing the database driver to use
+// its default behavior.
+//
+// For that this struct implements both the `sql.Scanner` and `sql.Valuer` interfaces.
+type attrModifier struct {
+	ctx context.Context
+
+	// When Scanning this value should be a pointer to the attribute
+	// and when "Valuing" it should just be the actual value
+	attr interface{}
+
+	modifierName string
+	opInfo       OpInfo
+}
+
+// Scan implements the sql.Scanner interface
+func (a attrModifier) Scan(dbValue interface{}) error {
+	return modifiers[a.modifierName].AttrScan(a.ctx, a.opInfo, a.attr, dbValue)
+}
+
+// Value implements the sql.Valuer interface
+func (a attrModifier) Value() (driver.Value, error) {
+	return modifiers[a.modifierName].AttrValue(a.ctx, a.opInfo, a.attr)
+}

attr_serializers.go

@@ -1,66 +0,0 @@
-package ksql
-
-import (
-	"context"
-	"database/sql/driver"
-	"fmt"
-)
-
-// Here we keep all the registered serializers
-var serializers = map[string]AttrSerializer{
-	"json": jsonSerializer{},
-}
-
-// RegisterAttrSerializer allow users to add custom serializers on startup
-// it is recommended to do this inside an init() function.
-func RegisterAttrSerializer(key string, serializer AttrSerializer) {
-	_, found := serializers[key]
-	if found {
-		panic(fmt.Errorf("KSQL: cannot register serializer '%s' name is already in use", key))
-	}
-
-	serializers[key] = serializer
-}
-
-// AttrSerializer describes the two operations required to serialize and deserialize an object from the database.
-type AttrSerializer interface {
-	AttrScan(ctx context.Context, opInfo OpInfo, attrPtr interface{}, dbValue interface{}) error
-	AttrValue(ctx context.Context, opInfo OpInfo, inputValue interface{}) (outputValue interface{}, _ error)
-}
-
-// OpInfo contains information that might be used by a serializer to determine how it should behave.
-type OpInfo struct {
-	// A string version of the name of one of
-	// the methods of the `ksql.Provider` interface, e.g. `Insert` or `Query`
-	Method string
-
-	// The string representing the current underlying database, e.g.:
-	// "postgres", "sqlite3", "mysql" or "sqlserver".
-	DriverName string
-}
-
-// attrSerializer is the wrapper that allow us to intercept the Scan and Value processes
-// so we can run the serializers instead of allowing the database driver to use
-// its default behavior.
-//
-// For that this struct implements both the `sql.Scanner` and `sql.Valuer` interfaces.
-type attrSerializer struct {
-	ctx context.Context
-
-	// When Scanning this value should be a pointer to the attribute
-	// and when "Valuing" it should just be the actual value
-	attr interface{}
-
-	serializerName string
-	opInfo         OpInfo
-}
-
-// Scan implements the sql.Scanner interface
-func (a attrSerializer) Scan(dbValue interface{}) error {
-	return serializers[a.serializerName].AttrScan(a.ctx, a.opInfo, a.attr, dbValue)
-}
-
-// Value implements the sql.Valuer interface
-func (a attrSerializer) Value() (driver.Value, error) {
-	return serializers[a.serializerName].AttrValue(a.ctx, a.opInfo, a.attr)
-}

internal/structs/structs.go

@@ -23,7 +23,7 @@ type FieldInfo struct {
 	Name         string
 	Index        int
 	Valid        bool
-	SerializerName string
+	ModifierName string
 }
 
 // ByIndex returns either the *FieldInfo of a valid
@@ -249,10 +249,10 @@ func getTagNames(t reflect.Type) (StructInfo, error) {
 		}
 
 		tags := strings.Split(name, ",")
-		var serializerName string
+		var modifierName string
 		if len(tags) > 1 {
 			name = tags[0]
-			serializerName = tags[1]
+			modifierName = tags[1]
 		}
 
 		if _, found := info.byName[name]; found {
@@ -265,7 +265,7 @@ func getTagNames(t reflect.Type) (StructInfo, error) {
 		info.add(FieldInfo{
 			Name:         name,
 			Index:        i,
-			SerializerName: serializerName,
+			ModifierName: modifierName,
 		})
 	}
 

json.go

@@ -10,11 +10,11 @@ import (
 // This type was created to make it easier to adapt
 // input attributes to be convertible to and from JSON
 // before sending or receiving it from the database.
-type jsonSerializer struct{}
+type jsonModifier struct{}
 
 // Scan Implements the Scanner interface in order to load
 // this field from the JSON stored in the database
-func (j jsonSerializer) AttrScan(ctx context.Context, opInfo OpInfo, attrPtr interface{}, dbValue interface{}) error {
+func (j jsonModifier) AttrScan(ctx context.Context, opInfo OpInfo, attrPtr interface{}, dbValue interface{}) error {
 	if dbValue == nil {
 		v := reflect.ValueOf(attrPtr)
 		// Set the struct to its 0 value just like json.Unmarshal
@@ -37,7 +37,7 @@ func (j jsonSerializer) AttrScan(ctx context.Context, opInfo OpInfo, attrPtr int
 
 // Value Implements the Valuer interface in order to save
 // this field as JSON on the database.
-func (j jsonSerializer) AttrValue(ctx context.Context, opInfo OpInfo, inputValue interface{}) (outputValue interface{}, _ error) {
+func (j jsonModifier) AttrValue(ctx context.Context, opInfo OpInfo, inputValue interface{}) (outputValue interface{}, _ error) {
 	b, err := json.Marshal(inputValue)
 	if opInfo.DriverName == "sqlserver" {
 		return string(b), err

ksql.go

@@ -718,12 +718,12 @@ func buildInsertQuery(
 		recordValue := recordMap[col]
 		params[i] = recordValue
 
-		serializerName := info.ByName(col).SerializerName
-		if serializerName != "" {
-			params[i] = attrSerializer{
+		modifierName := info.ByName(col).ModifierName
+		if modifierName != "" {
+			params[i] = attrModifier{
 				ctx:          ctx,
 				attr:         recordValue,
-				serializerName: serializerName,
+				modifierName: modifierName,
 				opInfo: OpInfo{
 					DriverName: dialect.DriverName(),
 					Method:     "Insert",
@@ -827,12 +827,12 @@ func buildUpdateQuery(
 	for i, k := range keys {
 		recordValue := recordMap[k]
 
-		serializerName := info.ByName(k).SerializerName
-		if serializerName != "" {
-			recordValue = attrSerializer{
+		modifierName := info.ByName(k).ModifierName
+		if modifierName != "" {
+			recordValue = attrModifier{
 				ctx:          ctx,
 				attr:         recordValue,
-				serializerName: serializerName,
+				modifierName: modifierName,
 				opInfo: OpInfo{
 					DriverName: dialect.DriverName(),
 					Method:     "Update",
@@ -1032,15 +1032,15 @@ func getScanArgsForNestedStructs(
 			if fieldInfo.Valid {
 				valueScanner = nestedStructValue.Field(fieldInfo.Index).Addr().Interface()
 
-				if fieldInfo.SerializerName != "" {
-					valueScanner = &attrSerializer{
+				if fieldInfo.ModifierName != "" {
+					valueScanner = &attrModifier{
 						ctx:          ctx,
 						attr:         valueScanner,
-						serializerName: fieldInfo.SerializerName,
+						modifierName: fieldInfo.ModifierName,
 						opInfo: OpInfo{
 							DriverName: dialect.DriverName(),
 							// We will not differentiate between Query, QueryOne and QueryChunks
-							// if we did this could lead users to make very strange serializers
+							// if we did this could lead users to make very strange modifiers
 							Method: "Query",
 						},
 					}
@@ -1062,15 +1062,15 @@ func getScanArgsFromNames(ctx context.Context, dialect Dialect, names []string,
 		valueScanner := nopScannerValue
 		if fieldInfo.Valid {
 			valueScanner = v.Field(fieldInfo.Index).Addr().Interface()
-			if fieldInfo.SerializerName != "" {
-				valueScanner = &attrSerializer{
+			if fieldInfo.ModifierName != "" {
+				valueScanner = &attrModifier{
 					ctx:          ctx,
 					attr:         valueScanner,
-					serializerName: fieldInfo.SerializerName,
+					modifierName: fieldInfo.ModifierName,
 					opInfo: OpInfo{
 						DriverName: dialect.DriverName(),
 						// We will not differentiate between Query, QueryOne and QueryChunks
-						// if we did this could lead users to make very strange serializers
+						// if we did this could lead users to make very strange modifiers
 						Method: "Query",
 					},
 				}

test_adapters.go

@@ -2799,14 +2799,14 @@ func getUserByID(db DBAdapter, dialect Dialect, result *user, id uint) error {
 		return sql.ErrNoRows
 	}
 
-	value := attrSerializer{
+	value := attrModifier{
 		ctx:          context.TODO(),
 		attr:         &result.Address,
-		serializerName: "json",
+		modifierName: "json",
 		opInfo: OpInfo{
 			DriverName: dialect.DriverName(),
 			// We will not differentiate between Query, QueryOne and QueryChunks
-			// if we did this could lead users to make very strange serializers
+			// if we did this could lead users to make very strange modifiers
 			Method: "Query",
 		},
 	}