refactor: rename proto messages to avoid native type conflicts

Author: tolgaozen

internal/engines/check.go

@@ -412,7 +412,7 @@ func (engine *CheckEngine) checkTupleToUserSet(
 // ComputedUserSet data structure. It returns a CheckFunction closure that performs the check.
 func (engine *CheckEngine) checkComputedUserSet(
 	request *base.PermissionCheckRequest, // The request containing details about the permission to be checked
-	cu *base.ComputedUserSet, // The computed user set containing user set information
+	cu *base.ComputedUserSet,             // The computed user set containing user set information
 ) CheckFunction {
 	// The returned CheckFunction invokes a permission check with a new request that is almost the same
 	// as the incoming request, but changes the Permission to be the relation defined in the computed user set.
@@ -496,14 +496,14 @@ func (engine *CheckEngine) checkDirectAttribute(
 		}
 
 		// Unmarshal the attribute value into a BoolValue message.
-		var msg base.Boolean
+		var msg base.BoolValue
 		if err := val.GetValue().UnmarshalTo(&msg); err != nil {
 			// If there was an error unmarshaling, return a denied response and the error.
 			return denied(&base.PermissionCheckResponseMetadata{}), err
 		}
 
 		// If the attribute's value is true, return an allowed response.
-		if msg.Value {
+		if msg.Data {
 			return allowed(&base.PermissionCheckResponseMetadata{}), nil
 		}
 
@@ -516,7 +516,7 @@ func (engine *CheckEngine) checkDirectAttribute(
 // It returns a function (CheckFunction) that when called, performs the permission check.
 func (engine *CheckEngine) checkCall(
 	request *base.PermissionCheckRequest, // The request containing the details for the permission check
-	call *base.Call, // The specific call to be checked
+	call *base.Call,                      // The specific call to be checked
 ) CheckFunction {
 	// The function returned by checkCall
 	return func(ctx context.Context) (*base.PermissionCheckResponse, error) {

internal/engines/expand.go

@@ -519,7 +519,7 @@ func (engine *ExpandEngine) expandDirectAttribute(
 				},
 				Attribute: request.GetPermission(),
 			}
-			val.Value, err = anypb.New(&base.Boolean{Value: false})
+			val.Value, err = anypb.New(&base.BoolValue{Data: false})
 			if err != nil {
 				expandChan <- expandFailResponse(err)
 				return
@@ -550,7 +550,7 @@ func (engine *ExpandEngine) expandDirectAttribute(
 // It takes a PermissionExpandRequest and a Call as parameters and returns an ExpandFunction.
 func (engine *ExpandEngine) expandCall(
 	request *base.PermissionExpandRequest, // The request object containing information necessary for the expansion.
-	call *base.Call, // The call object that defines the rule name and its arguments.
+	call *base.Call,                       // The call object that defines the rule name and its arguments.
 ) ExpandFunction { // The function returns an ExpandFunction.
 	return func(ctx context.Context, expandChan chan<- ExpandResponse) { // defining the returned function.
 
@@ -688,7 +688,7 @@ func (engine *ExpandEngine) expandCall(
 // It takes a PermissionExpandRequest and a ComputedAttribute as parameters and returns an ExpandFunction.
 func (engine *ExpandEngine) expandComputedAttribute(
 	request *base.PermissionExpandRequest, // The request object containing necessary information for the expansion.
-	ca *base.ComputedAttribute, // The computed attribute object that has the name of the attribute to be computed.
+	ca *base.ComputedAttribute,            // The computed attribute object that has the name of the attribute to be computed.
 ) ExpandFunction { // The function returns an ExpandFunction.
 	return func(ctx context.Context, resultChan chan<- ExpandResponse) { // defining the returned function.
 
@@ -712,11 +712,11 @@ func (engine *ExpandEngine) expandComputedAttribute(
 // a slice of arguments, slice of ExpandFunctions, and an operation of type base.ExpandTreeNode_Operation.
 // It returns an ExpandResponse.
 func expandOperation(
-	ctx context.Context, // The context of this operation, which may carry deadlines, cancellation signals, etc.
-	entity *base.Entity, // The entity on which the operation will be performed.
-	permission string, // The permission string required for the operation.
-	arguments []*base.Argument, // A slice of arguments required for the operation.
-	functions []ExpandFunction, // A slice of functions that will be used to expand the operation.
+	ctx context.Context,              // The context of this operation, which may carry deadlines, cancellation signals, etc.
+	entity *base.Entity,              // The entity on which the operation will be performed.
+	permission string,                // The permission string required for the operation.
+	arguments []*base.Argument,       // A slice of arguments required for the operation.
+	functions []ExpandFunction,       // A slice of functions that will be used to expand the operation.
 	op base.ExpandTreeNode_Operation, // The operation to be performed.
 ) ExpandResponse { // The function returns an ExpandResponse.
 

internal/engines/utils.go

@@ -169,63 +169,63 @@ func getEmptyProtoValueForType(typ base.AttributeType) (*anypb.Any, error) {
 	switch typ {
 	case base.AttributeType_ATTRIBUTE_TYPE_STRING:
 		// Create an empty protobuf String message
-		value, err := anypb.New(&base.String{Value: ""})
+		value, err := anypb.New(&base.StringValue{Data: ""})
 		if err != nil {
 			return nil, err
 		}
 		return value, nil
 
 	case base.AttributeType_ATTRIBUTE_TYPE_STRING_ARRAY:
 		// Create an empty protobuf StringArray message
-		value, err := anypb.New(&base.StringArray{Values: []string{}})
+		value, err := anypb.New(&base.StringArrayValue{Data: []string{}})
 		if err != nil {
 			return nil, err
 		}
 		return value, nil
 
 	case base.AttributeType_ATTRIBUTE_TYPE_INTEGER:
 		// Create an empty protobuf Integer message
-		value, err := anypb.New(&base.Integer{Value: 0})
+		value, err := anypb.New(&base.IntegerValue{Data: 0})
 		if err != nil {
 			return nil, err
 		}
 		return value, nil
 
 	case base.AttributeType_ATTRIBUTE_TYPE_INTEGER_ARRAY:
 		// Create an empty protobuf IntegerArray message
-		value, err := anypb.New(&base.IntegerArray{Values: []int32{}})
+		value, err := anypb.New(&base.IntegerArrayValue{Data: []int32{}})
 		if err != nil {
 			return nil, err
 		}
 		return value, nil
 
 	case base.AttributeType_ATTRIBUTE_TYPE_DOUBLE:
 		// Create an empty protobuf Double message
-		value, err := anypb.New(&base.Double{Value: 0.0})
+		value, err := anypb.New(&base.DoubleValue{Data: 0.0})
 		if err != nil {
 			return nil, err
 		}
 		return value, nil
 
 	case base.AttributeType_ATTRIBUTE_TYPE_DOUBLE_ARRAY:
 		// Create an empty protobuf DoubleArray message
-		value, err := anypb.New(&base.DoubleArray{Values: []float64{}})
+		value, err := anypb.New(&base.DoubleArrayValue{Data: []float64{}})
 		if err != nil {
 			return nil, err
 		}
 		return value, nil
 
 	case base.AttributeType_ATTRIBUTE_TYPE_BOOLEAN:
 		// Create an empty protobuf Boolean message with a default value of false
-		value, err := anypb.New(&base.Boolean{Value: false})
+		value, err := anypb.New(&base.BoolValue{Data: false})
 		if err != nil {
 			return nil, err
 		}
 		return value, nil
 
 	case base.AttributeType_ATTRIBUTE_TYPE_BOOLEAN_ARRAY:
 		// Create an empty protobuf BooleanArray message
-		value, err := anypb.New(&base.BooleanArray{Values: []bool{}})
+		value, err := anypb.New(&base.BoolArrayValue{Data: []bool{}})
 		if err != nil {
 			return nil, err
 		}
@@ -249,21 +249,21 @@ func ConvertToAnyPB(value interface{}) (*anypb.Any, error) {
 	// Use a type switch to handle different types of value.
 	switch v := value.(type) {
 	case bool:
-		anyValue, err = anypb.New(&base.Boolean{Value: v})
+		anyValue, err = anypb.New(&base.BoolValue{Data: v})
 	case []bool:
-		anyValue, err = anypb.New(&base.BooleanArray{Values: v})
+		anyValue, err = anypb.New(&base.BoolArrayValue{Data: v})
 	case int:
-		anyValue, err = anypb.New(&base.Integer{Value: int32(v)})
+		anyValue, err = anypb.New(&base.IntegerValue{Data: int32(v)})
 	case []int32:
-		anyValue, err = anypb.New(&base.IntegerArray{Values: v})
+		anyValue, err = anypb.New(&base.IntegerArrayValue{Data: v})
 	case float64:
-		anyValue, err = anypb.New(&base.Double{Value: v})
+		anyValue, err = anypb.New(&base.DoubleValue{Data: v})
 	case []float64:
-		anyValue, err = anypb.New(&base.DoubleArray{Values: v})
+		anyValue, err = anypb.New(&base.DoubleArrayValue{Data: v})
 	case string:
-		anyValue, err = anypb.New(&base.String{Value: v})
+		anyValue, err = anypb.New(&base.StringValue{Data: v})
 	case []string:
-		anyValue, err = anypb.New(&base.StringArray{Values: v})
+		anyValue, err = anypb.New(&base.StringArrayValue{Data: v})
 	default:
 		// In case of an unsupported or unknown type, we return an error.
 		return nil, errors.New("unknown type")

pkg/attribute/attribute.go

@@ -58,7 +58,7 @@ func Attribute(attribute string) (*base.Attribute, error) {
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse boolean: %v", err)
 		}
-		wrapped = &base.Boolean{Value: boolVal}
+		wrapped = &base.BoolValue{Data: boolVal}
 	case "boolean[]":
 		var ba []bool
 		val := strings.Split(v[1], ",")
@@ -69,22 +69,22 @@ func Attribute(attribute string) (*base.Attribute, error) {
 			}
 			ba = append(ba, boolVal)
 		}
-		wrapped = &base.BooleanArray{Values: ba}
+		wrapped = &base.BoolArrayValue{Data: ba}
 	case "string":
-		wrapped = &base.String{Value: v[1]}
+		wrapped = &base.StringValue{Data: v[1]}
 	case "string[]":
 		var sa []string
 		val := strings.Split(v[1], ",")
 		for _, value := range val {
 			sa = append(sa, value)
 		}
-		wrapped = &base.StringArray{Values: sa}
+		wrapped = &base.StringArrayValue{Data: sa}
 	case "double":
 		doubleVal, err := strconv.ParseFloat(v[1], 64)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse float: %v", err)
 		}
-		wrapped = &base.Double{Value: doubleVal}
+		wrapped = &base.DoubleValue{Data: doubleVal}
 	case "double[]":
 		var da []float64
 		val := strings.Split(v[1], ",")
@@ -95,13 +95,13 @@ func Attribute(attribute string) (*base.Attribute, error) {
 			}
 			da = append(da, doubleVal)
 		}
-		wrapped = &base.DoubleArray{Values: da}
+		wrapped = &base.DoubleArrayValue{Data: da}
 	case "integer":
 		intVal, err := strconv.ParseInt(v[1], 10, 32)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse integer: %v", err)
 		}
-		wrapped = &base.Integer{Value: int32(intVal)}
+		wrapped = &base.IntegerValue{Data: int32(intVal)}
 	case "integer[]":
 
 		var ia []int32
@@ -113,7 +113,7 @@ func Attribute(attribute string) (*base.Attribute, error) {
 			}
 			ia = append(ia, int32(intVal))
 		}
-		wrapped = &base.IntegerArray{Values: ia}
+		wrapped = &base.IntegerArrayValue{Data: ia}
 	default:
 		return nil, ErrInvalidValue
 	}
@@ -184,66 +184,66 @@ func AnyToString(any *anypb.Any) string {
 	// Convert the Any proto message into string based on its TypeUrl
 	switch any.TypeUrl {
 	case "type.googleapis.com/base.v1.Boolean":
-		boolVal := &base.Boolean{}
+		boolVal := &base.BoolValue{}
 		if err := any.UnmarshalTo(boolVal); err != nil {
 			return "undefined"
 		}
-		str = strconv.FormatBool(boolVal.Value)
+		str = strconv.FormatBool(boolVal.Data)
 	case "type.googleapis.com/base.v1.BooleanArray":
-		boolVal := &base.BooleanArray{}
+		boolVal := &base.BoolArrayValue{}
 		if err := any.UnmarshalTo(boolVal); err != nil {
 			return "undefined"
 		}
 		var strs []string
-		for _, b := range boolVal.GetValues() {
+		for _, b := range boolVal.GetData() {
 			strs = append(strs, strconv.FormatBool(b))
 		}
 		str = strings.Join(strs, ",")
 	case "type.googleapis.com/base.v1.String":
-		stringVal := &base.String{}
+		stringVal := &base.StringValue{}
 		if err := any.UnmarshalTo(stringVal); err != nil {
 			return "undefined"
 		}
-		str = stringVal.Value
+		str = stringVal.Data
 	case "type.googleapis.com/base.v1.StringArray":
-		stringVal := &base.StringArray{}
+		stringVal := &base.StringArrayValue{}
 		if err := any.UnmarshalTo(stringVal); err != nil {
 			return "undefined"
 		}
 		var strs []string
-		for _, v := range stringVal.GetValues() {
+		for _, v := range stringVal.GetData() {
 			strs = append(strs, v)
 		}
 		str = strings.Join(strs, ",")
 	case "type.googleapis.com/base.v1.Double":
-		doubleVal := &base.Double{}
+		doubleVal := &base.DoubleValue{}
 		if err := any.UnmarshalTo(doubleVal); err != nil {
 			return "undefined"
 		}
-		str = strconv.FormatFloat(doubleVal.Value, 'f', -1, 64)
+		str = strconv.FormatFloat(doubleVal.Data, 'f', -1, 64)
 	case "type.googleapis.com/base.v1.DoubleArray":
-		doubleVal := &base.DoubleArray{}
+		doubleVal := &base.DoubleArrayValue{}
 		if err := any.UnmarshalTo(doubleVal); err != nil {
 			return "undefined"
 		}
 		var strs []string
-		for _, v := range doubleVal.GetValues() {
+		for _, v := range doubleVal.GetData() {
 			strs = append(strs, strconv.FormatFloat(v, 'f', -1, 64))
 		}
 		str = strings.Join(strs, ",")
 	case "type.googleapis.com/base.v1.Integer":
-		intVal := &base.Integer{}
+		intVal := &base.IntegerValue{}
 		if err := any.UnmarshalTo(intVal); err != nil {
 			return "undefined"
 		}
-		str = strconv.Itoa(int(intVal.Value))
+		str = strconv.Itoa(int(intVal.Data))
 	case "type.googleapis.com/base.v1.IntegerArray":
-		intVal := &base.IntegerArray{}
+		intVal := &base.IntegerArrayValue{}
 		if err := any.UnmarshalTo(intVal); err != nil {
 			return "undefined"
 		}
 		var strs []string
-		for _, v := range intVal.GetValues() {
+		for _, v := range intVal.GetData() {
 			strs = append(strs, strconv.Itoa(int(v)))
 		}
 		str = strings.Join(strs, ",")
@@ -293,21 +293,21 @@ func ValidateValue(any *anypb.Any, attributeType base.AttributeType) error {
 	// Depending on the expected attribute type, assign 'target' a new instance of the corresponding specific type.
 	switch attributeType {
 	case base.AttributeType_ATTRIBUTE_TYPE_INTEGER:
-		target = &base.Integer{}
+		target = &base.IntegerValue{}
 	case base.AttributeType_ATTRIBUTE_TYPE_INTEGER_ARRAY:
-		target = &base.IntegerArray{}
+		target = &base.IntegerArrayValue{}
 	case base.AttributeType_ATTRIBUTE_TYPE_DOUBLE:
-		target = &base.Double{}
+		target = &base.DoubleValue{}
 	case base.AttributeType_ATTRIBUTE_TYPE_DOUBLE_ARRAY:
-		target = &base.DoubleArray{}
+		target = &base.DoubleArrayValue{}
 	case base.AttributeType_ATTRIBUTE_TYPE_STRING:
-		target = &base.String{}
+		target = &base.StringValue{}
 	case base.AttributeType_ATTRIBUTE_TYPE_STRING_ARRAY:
-		target = &base.StringArray{}
+		target = &base.StringArrayValue{}
 	case base.AttributeType_ATTRIBUTE_TYPE_BOOLEAN:
-		target = &base.Boolean{}
+		target = &base.BoolValue{}
 	case base.AttributeType_ATTRIBUTE_TYPE_BOOLEAN_ARRAY:
-		target = &base.BooleanArray{}
+		target = &base.BoolArrayValue{}
 	default:
 		// If attributeType doesn't match any of the known types, return an error indicating invalid argument.
 		return errors.New(base.ErrorCode_ERROR_CODE_INVALID_ARGUMENT.String())