Refactoring Client/Server Operation model (#201)

* Refactoring Client/Server Operation model

* Operation Model Refactor

Author: Varun-Sethu

backend/OTClient/operationModel.ts

@@ -0,0 +1,42 @@
+// integer operation
+type integerOperation = {
+    newValue: number
+}
+
+type booleanOperation = {
+    newValue: boolean
+}
+
+// string based operations
+type stringOperation = {
+    operationType: "insert" | "delete";
+    rangeStart: number, rangeEnd: number;
+
+    newValue?: string;
+}
+
+// array based operations
+type arrayOperation = {
+    index: number
+    
+    payload: {
+        $type: string
+        value: object
+    }
+}
+
+// object based operations
+type objectOperation = {
+    $type: string,
+    value: object
+}
+
+// the generic operation type
+type operation = {
+    $type: "integerOperation" | "booleanOperation" | 
+            "arrayOperation" | "objectOperation",
+
+    path: number[],
+    operation: integerOperation | booleanOperation | 
+                arrayOperation | objectOperation;
+}

backend/editor/OT/client_view.go

@@ -14,15 +14,15 @@ import (
 type clientView struct {
 	socket *websocket.Conn
 
-	sendOp              chan data.OperationRequest
+	sendOp              chan data.Operation
 	sendAcknowledgement chan empty
 	sendTerminateSignal chan empty
 }
 
 func newClient(socket *websocket.Conn) *clientView {
 	return &clientView{
 		socket:              socket,
-		sendOp:              make(chan data.OperationRequest),
+		sendOp:              make(chan data.Operation),
 		sendAcknowledgement: make(chan empty),
 		sendTerminateSignal: make(chan empty),
 	}
@@ -52,7 +52,7 @@ func (c *clientView) run(serverPipe pipe, terminatePipe alertLeaving) {
 			return
 
 		default:
-			request := data.OperationRequest{}
+			request := data.Operation{}
 
 			err := c.socket.ReadJSON(&request)
 			if err != nil {

backend/editor/OT/data/applicator.go

@@ -3,29 +3,20 @@ package data
 // applicator manages the application of request objects to a provided datamodel
 
 import (
-	"errors"
 	"reflect"
 
 	"cms.csesoc.unsw.edu.au/editor/OT/data/datamodels"
 )
 
 // ApplyRequest takes a datamodel (as defined in the datamodels folder) and a request, it then proceeds to apply the request
 // to the model, note that this assumes that the operation in the request has been appropriately transformed
-func ApplyRequest(model datamodels.DataModel, request OperationRequest) error {
+func ApplyRequest(model datamodels.DataModel, request Operation) error {
 	// TODO: Use Gary's code here to get the indice path
 	_, err := GetOperationTargetSite(model, []int{})
 	if err != nil {
 		return err
 	}
 
-	switch editType := request.OperationPayload.GetType(); editType {
-	case TextEditType:
-	case KeyEditType:
-	case ArrayEditType:
-	default:
-		return errors.New("invalid edit type")
-	}
-
 	return nil
 }
 

backend/editor/OT/data/array_operation.go

@@ -0,0 +1,23 @@
+package data
+
+import (
+	"cms.csesoc.unsw.edu.au/editor/OT/data/datamodels"
+	"cms.csesoc.unsw.edu.au/pkg/cmsjson"
+)
+
+// ArrayOperation is an operation on an array type
+// @implements OperationModel
+type ArrayOperation struct {
+	index   int
+	payload datamodels.DataType
+}
+
+// TransformAgainst is the ArrayOperation implementation of the operationModel interface
+func (arrOp ArrayOperation) TransformAgainst(operation OperationModel) (OperationModel, OperationModel) {
+	return arrOp, operation
+}
+
+// Apply is the ArrayOperation implementation of the OperationModel interface, it does nothing
+func (arrOp ArrayOperation) Apply(ast cmsjson.AstNode) cmsjson.AstNode {
+	return ast
+}

backend/editor/OT/data/boolean_operation.go

@@ -0,0 +1,19 @@
+package data
+
+import "cms.csesoc.unsw.edu.au/pkg/cmsjson"
+
+// BooleanOperations represents an operation on a boolean type
+// @implements OperationModel
+type BooleanOperation struct {
+	newValue bool
+}
+
+// TransformAgainst is the BooleanOperation implementation of the operationModel interface
+func (boolOp BooleanOperation) TransformAgainst(operation OperationModel) (OperationModel, OperationModel) {
+	return boolOp, operation
+}
+
+// Apply is the BooleanOperation implementation of the OperationModel interface, it does nothing
+func (boolOp BooleanOperation) Apply(ast cmsjson.AstNode) cmsjson.AstNode {
+	return ast
+}

backend/editor/OT/data/datamodels/main.go

@@ -6,3 +6,7 @@ package datamodels
 type DataModel interface {
 	IsExposed() bool
 }
+
+// DataType is a series of types that can be used within your datamodel, they require registration in the
+// json configuration file
+type DataType interface{}

backend/editor/OT/data/integer_operation.go

@@ -0,0 +1,19 @@
+package data
+
+import "cms.csesoc.unsw.edu.au/pkg/cmsjson"
+
+// IntegerOperation represents an operation on an integer type
+// @implementations of OperationModel
+type IntegerOperation struct {
+	newValue int
+}
+
+// TransformAgainst is the IntegerOperation implementation of the operationModel interface
+func (intOp IntegerOperation) TransformAgainst(operation OperationModel) (OperationModel, OperationModel) {
+	return intOp, operation
+}
+
+// Apply is the IntegerOperation implementation of the OperationModel interface, it does nothing
+func (intOp IntegerOperation) Apply(ast cmsjson.AstNode) cmsjson.AstNode {
+	return ast
+}

backend/editor/OT/data/jsonConfig.go renamed to backend/editor/OT/data/json_config.go

@@ -1,9 +1,7 @@
 package data
 
 import (
-	"errors"
 	"reflect"
-	"strconv"
 
 	"cms.csesoc.unsw.edu.au/editor/OT/data/datamodels/cmsmodel"
 	"cms.csesoc.unsw.edu.au/pkg/cmsjson"
@@ -19,33 +17,20 @@ var cmsJsonConf = cmsjson.Configuration{
 	// Registration for cmsmodel, when the LP is finally merged with CSESoc Projects
 	// this will also contain the registration for their data models
 	RegisteredTypes: map[reflect.Type]map[string]reflect.Type{
+		// TODO: later allow this to be dynamically swapped out for different front-ends
 		reflect.TypeOf((*cmsmodel.Component)(nil)).Elem(): {
 			"image":     reflect.TypeOf(cmsmodel.Image{}),
 			"paragraph": reflect.TypeOf(cmsmodel.Paragraph{}),
 		},
 
-		reflect.TypeOf((*Payload)(nil)).Elem(): {
-			"textEdit":  reflect.TypeOf(TextEdit{}),
-			"keyEdit":   reflect.TypeOf(KeyEdit{}),
-			"arrayEdit": reflect.TypeOf(ArrayEdit{}),
+		// Type registrations for the OperationModel
+		reflect.TypeOf((*OperationModel)(nil)).Elem(): {
+			"integerOperation": reflect.TypeOf(IntegerOperation{}),
+			"booleanOperation": reflect.TypeOf(BooleanOperation{}),
+			"stringOperation":  reflect.TypeOf(StringOperation{}),
+
+			"arrayOperation":  reflect.TypeOf(ArrayOperation{}),
+			"objectOperation": reflect.TypeOf(ObjectOperation{}),
 		},
 	},
 }
-
-// small helper function to parse a JSON value of a specific type
-func parseDataGivenType(dataStr string, dataType string) (interface{}, error) {
-	switch dataType {
-	case "integer":
-		return strconv.Atoi(dataStr)
-	case "boolean":
-		return strconv.ParseBool(dataStr)
-	case "float":
-		return strconv.ParseFloat(dataStr, 64)
-	case "string":
-		return dataStr, nil
-	case "component":
-		// todo: later
-		return nil, nil
-	}
-	return nil, errors.New("unable to parse data type")
-}

backend/editor/OT/data/noop_operation.go

@@ -0,0 +1,17 @@
+package data
+
+import "cms.csesoc.unsw.edu.au/pkg/cmsjson"
+
+// Noop represents a non-existent operation
+// @implements OperationModel
+type Noop struct{}
+
+// TransformAgainst is the noop implementation of the operationModel interface
+func (noop Noop) TransformAgainst(operation OperationModel) (OperationModel, OperationModel) {
+	return noop, operation
+}
+
+// Apply is the noop implementation of the OperationModel interface, it does nothing
+func (noop Noop) Apply(ast cmsjson.AstNode) cmsjson.AstNode {
+	return ast
+}

backend/editor/OT/data/object_operation.go

@@ -0,0 +1,21 @@
+package data
+
+import (
+	"cms.csesoc.unsw.edu.au/editor/OT/data/datamodels"
+	"cms.csesoc.unsw.edu.au/pkg/cmsjson"
+)
+
+// ObjectOperation represents an operation we perform on an object
+type ObjectOperation struct {
+	payload datamodels.DataType
+}
+
+// TransformAgainst is the ArrayOperation implementation of the operationModel interface
+func (objOp ObjectOperation) TransformAgainst(operation OperationModel) (OperationModel, OperationModel) {
+	return objOp, operation
+}
+
+// Apply is the ArrayOperation implementation of the OperationModel interface, it does nothing
+func (objOp ObjectOperation) Apply(ast cmsjson.AstNode) cmsjson.AstNode {
+	return ast
+}

backend/editor/OT/data/operationModel.go

@@ -0,0 +1,47 @@
+package data
+
+import (
+	"errors"
+
+	"cms.csesoc.unsw.edu.au/pkg/cmsjson"
+)
+
+type (
+	// EditType is the underlying type of an edit
+	EditType int
+
+	// OperationModel defines an simple interface an operation must implement
+	OperationModel interface {
+		TransformAgainst(OperationModel) (OperationModel, OperationModel)
+		Apply(cmsjson.AstNode) cmsjson.AstNode
+	}
+
+	// Operation is the fundamental incoming type from the frontend
+	Operation struct {
+		Path                  []int
+		OperationType         EditType
+		AcknowledgedServerOps int
+
+		IsNoOp    bool
+		Operation OperationModel
+	}
+)
+
+// EditType enum constants
+const (
+	Insert EditType = iota
+	Delete
+)
+
+// NoOperation is a special constant that signifies an operation that does nothing
+var NoOperation = Operation{IsNoOp: true, Operation: Noop{}}
+
+// Parse is a utility function that takes a JSON stream and parses the input into
+// a Request object
+func ParseOperation(request string) (Operation, error) {
+	if operation, err := cmsjson.Unmarshall[Operation](cmsJsonConf, []byte(request)); err != nil {
+		return Operation{}, errors.New("invalid request format")
+	} else {
+		return *operation, nil
+	}
+}