Support cel_expression

Signed-off-by: Sri Krishna <[email protected]>

Author: srikrsna-buf

build.gradle.kts

@@ -172,7 +172,7 @@ tasks.register<Exec>("exportProtovalidateModule") {
     commandLine(
         buf.asPath,
         "export",
-        "buf.build/bufbuild/protovalidate:${project.findProperty("protovalidate.version")}",
+        "https://github.com/bufbuild/protovalidate.git#subdir=proto/protovalidate,ref=${project.findProperty("protovalidate.version")}",
         "--output",
         "src/main/resources",
     )

conformance/build.gradle.kts

@@ -70,7 +70,9 @@ tasks.register<Exec>("generateConformance") {
         "generate",
         "--template",
         "${layout.buildDirectory.get()}/buf-gen-templates/buf.gen.yaml",
-        "buf.build/bufbuild/protovalidate-testing:${project.findProperty("protovalidate.version")}",
+        "https://github.com/bufbuild/protovalidate.git#subdir=proto/protovalidate-testing,ref=${project.findProperty(
+            "protovalidate.version",
+        )}",
     )
 }
 

gradle.properties

@@ -1,5 +1,5 @@
 # Version of buf.build/bufbuild/protovalidate to use.
-protovalidate.version = v1.0.0
+protovalidate.version = 774f3764e09fcfc921b3ef5a42271754f0b7063a
 
 # Arguments to the protovalidate-conformance CLI
 protovalidate.conformance.args = --strict_message --strict_error --expected_failures=expected-failures.yaml

src/main/java/build/buf/protovalidate/EvaluatorBuilder.java

@@ -42,6 +42,8 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import org.jspecify.annotations.Nullable;
 
 /** A build-through cache of message evaluators keyed off the provided descriptor. */
@@ -50,6 +52,10 @@ final class EvaluatorBuilder {
       FieldPathUtils.fieldPathElement(
           FieldRules.getDescriptor().findFieldByNumber(FieldRules.CEL_FIELD_NUMBER));
 
+  private static final FieldPathElement CEL_EXPRESSION_FIELD_PATH_ELEMENT =
+      FieldPathUtils.fieldPathElement(
+          FieldRules.getDescriptor().findFieldByNumber(FieldRules.CEL_EXPRESSION_FIELD_NUMBER));
+
   private volatile Map<Descriptor, MessageEvaluator> evaluatorCache = Collections.emptyMap();
 
   private final Cel cel;
@@ -187,7 +193,11 @@ private void buildMessage(Descriptor desc, MessageEvaluator msgEval)
     private void processMessageExpressions(
         Descriptor desc, MessageRules msgRules, MessageEvaluator msgEval, DynamicMessage message)
         throws CompilationException {
-      List<Rule> celList = msgRules.getCelList();
+      List<Rule> celList =
+          Stream.concat(
+                  expressionsToRules(msgRules.getCelExpressionList()).stream(),
+                  msgRules.getCelList().stream())
+              .collect(Collectors.toList());
       if (celList.isEmpty()) {
         return;
       }
@@ -196,7 +206,7 @@ private void processMessageExpressions(
               .addMessageTypes(message.getDescriptorForType())
               .addVar(Variable.THIS_NAME, StructTypeReference.create(desc.getFullName()))
               .build();
-      List<CompiledProgram> compiledPrograms = compileRules(celList, finalCel, false);
+      List<CompiledProgram> compiledPrograms = compileRules(celList, finalCel, null);
       if (compiledPrograms.isEmpty()) {
         throw new CompilationException("compile returned null");
       }
@@ -354,7 +364,8 @@ private void processFieldExpressions(
         FieldDescriptor fieldDescriptor, FieldRules fieldRules, ValueEvaluator valueEvaluatorEval)
         throws CompilationException {
       List<Rule> rulesCelList = fieldRules.getCelList();
-      if (rulesCelList.isEmpty()) {
+      List<String> exprList = fieldRules.getCelExpressionList();
+      if (rulesCelList.isEmpty() && exprList.isEmpty()) {
         return;
       }
       CelBuilder builder = cel.toCelBuilder();
@@ -367,7 +378,16 @@ private void processFieldExpressions(
         builder = builder.addMessageTypes(fieldDescriptor.getMessageType());
       }
       Cel finalCel = builder.build();
-      List<CompiledProgram> compiledPrograms = compileRules(rulesCelList, finalCel, true);
+      List<CompiledProgram> compiledPrograms = new ArrayList<>();
+      if (!rulesCelList.isEmpty()) {
+        compiledPrograms.addAll(compileRules(rulesCelList, finalCel, CEL_FIELD_PATH_ELEMENT));
+      }
+      if (!exprList.isEmpty()) {
+        compiledPrograms.addAll(
+            compileRules(
+                expressionsToRules(exprList), finalCel, CEL_EXPRESSION_FIELD_PATH_ELEMENT));
+      }
+
       if (!compiledPrograms.isEmpty()) {
         valueEvaluatorEval.append(new CelPrograms(valueEvaluatorEval, compiledPrograms));
       }
@@ -510,19 +530,18 @@ private void processRepeatedRules(
       valueEvaluatorEval.append(listEval);
     }
 
-    private static List<CompiledProgram> compileRules(List<Rule> rules, Cel cel, boolean isField)
+    private static List<CompiledProgram> compileRules(
+        List<Rule> rules, Cel cel, @Nullable FieldPathElement fieldPathElement)
         throws CompilationException {
       List<Expression> expressions = Expression.fromRules(rules);
       List<CompiledProgram> compiledPrograms = new ArrayList<>();
       for (int i = 0; i < expressions.size(); i++) {
         Expression expression = expressions.get(i);
         AstExpression astExpression = AstExpression.newAstExpression(cel, expression);
         @Nullable FieldPath rulePath = null;
-        if (isField) {
+        if (fieldPathElement != null) {
           rulePath =
-              FieldPath.newBuilder()
-                  .addElements(CEL_FIELD_PATH_ELEMENT.toBuilder().setIndex(i))
-                  .build();
+              FieldPath.newBuilder().addElements(fieldPathElement.toBuilder().setIndex(i)).build();
         }
         try {
           compiledPrograms.add(
@@ -538,5 +557,11 @@ private static List<CompiledProgram> compileRules(List<Rule> rules, Cel cel, boo
       }
       return compiledPrograms;
     }
+
+    private static List<Rule> expressionsToRules(List<String> expressions) {
+      return expressions.stream()
+          .map(expr -> Rule.newBuilder().setExpression(expr).build())
+          .collect(Collectors.toList());
+    }
   }
 }

src/main/resources/buf/validate/validate.proto

@@ -109,6 +109,24 @@ message Rule {
 // MessageRules represents validation rules that are applied to the entire message.
 // It includes disabling options and a list of Rule messages representing Common Expression Language (CEL) validation rules.
 message MessageRules {
+  // `cel_expression` is a repeated field CEL expressions. Each expression specifies a validation
+  // rule to be applied to this message. These rules are written in Common Expression Language (CEL) syntax.
+  //
+  // This is a simplified form of the `cel` Rule field, where only `expression` is set. This allows for
+  // simpler syntax when defining CEL Rules where `id` and `message` are largely redundant.
+  //
+  // For more information, [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/).
+  //
+  // ```proto
+  // message MyMessage {
+  //   // The field `foo` must be greater than 42.
+  //   option (buf.validate.message).cel_expression = "this.foo > 42";
+  //   // The field `foo` must be less than 84.
+  //   option (buf.validate.message).cel_expression = "this.foo < 84";
+  //   optional int32 foo = 1;
+  // }
+  // ```
+  repeated string cel_expression = 5;
   // `cel` is a repeated field of type Rule. Each Rule specifies a validation rule to be applied to this message.
   // These rules are written in Common Expression Language (CEL) syntax. For more information,
   // [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/).
@@ -201,6 +219,21 @@ message OneofRules {
 // FieldRules encapsulates the rules for each type of field. Depending on
 // the field, the correct set should be used to ensure proper validations.
 message FieldRules {
+  // `cel_expression` is a repeated field CEL expressions. Each expression specifies a validation
+  // rule to be applied to this message. These rules are written in Common Expression Language (CEL) syntax.
+  //
+  // This is a simplified form of the `cel` Rule field, where only `expression` is set. This allows for
+  // simpler syntax when defining CEL Rules where `id` and `message` are largely redundant.
+  //
+  // For more information, [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/).
+  //
+  // ```proto
+  // message MyMessage {
+  //   // The field `value` must be greater than 42.
+  //   optional int32 value = 1 [(buf.validate.field).cel_expression = "this > 42"];
+  // }
+  // ```
+  repeated string cel_expression = 28;
   // `cel` is a repeated field used to represent a textual expression
   // in the Common Expression Language (CEL) syntax. For more information,
   // [see our documentation](https://buf.build/docs/protovalidate/schemas/custom-rules/).