support protovalidate validation

gradle/libs.versions.toml

@@ -13,6 +13,7 @@
 
 [versions]
 autoService = "1.1.1"
+cel = "0.4.4"
 grpc-java = "1.64.0"
 grpc-kotlin = "1.4.1"
 kotlinLogging = "5.1.0"
@@ -23,6 +24,8 @@ ktlint = "1.2.1"
 protobuf-java = "3.21.7"
 protobuf-js = "7.2.6"
 protobufGradlePlugin = "0.9.4"
+protovalidate = "0.6.4"
+protovalidateJava = "0.2.1"
 slf4j = "2.0.13"
 
 # build
@@ -44,6 +47,7 @@ jmh = "1.37"
 wire = "4.9.9"
 
 # test
+buf = "1.31.0"
 classgraph = "4.8.153"
 grpc-js = "1.8.14"
 jackson = "2.17.1"
@@ -62,6 +66,7 @@ wire = { id = "com.squareup.wire", version.ref = "wire" }
 [libraries]
 autoService = { module = "com.google.auto.service:auto-service", version.ref = "autoService" }
 autoServiceAnnotations = { module = "com.google.auto.service:auto-service-annotations", version.ref = "autoService" }
+cel = { module = "org.projectnessie.cel:cel-tools", version.ref = "cel" }
 grpc-kotlin-gen = { module = "io.grpc:protoc-gen-grpc-kotlin", version.ref = "grpc-kotlin" }
 grpc-netty = { module = "io.grpc:grpc-netty", version.ref = "grpc-java" }
 grpc-stub = { module = "io.grpc:grpc-stub", version.ref = "grpc-java" }
@@ -73,6 +78,7 @@ ktlintRuleSetStandard = { module = "com.pinterest.ktlint:ktlint-ruleset-standard
 protobuf-gradlePlugin = { module = "com.google.protobuf:protobuf-gradle-plugin", version.ref = "protobufGradlePlugin" }
 protobuf-java = { module ="com.google.protobuf:protobuf-java", version.ref = "protobuf-java" }
 protoc = { module = "com.google.protobuf:protoc", version.ref = "protobuf-java" }
+protovalidateJava = { module = "build.buf:protovalidate", version.ref = "protovalidateJava" }
 slf4jSimple = { module = "org.slf4j:slf4j-simple", version.ref = "slf4j" }
 
 # build

protokt-protovalidate/api/protokt-protovalidate.api

@@ -0,0 +1,8 @@
+public final class protokt/v1/buf/validate/Validator {
+	public fun <init> ()V
+	public fun <init> (Lbuild/buf/protovalidate/Config;)V
+	public synthetic fun <init> (Lbuild/buf/protovalidate/Config;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun load (Lcom/google/protobuf/Descriptors$Descriptor;)V
+	public final fun validate (Lprotokt/v1/Message;)Lbuild/buf/protovalidate/ValidationResult;
+}
+

protokt-protovalidate/build.gradle.kts

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2024 Toast, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+    id("protokt.jvm-conventions")
+}
+
+enablePublishing()
+trackKotlinApiCompatibility()
+
+dependencies {
+    implementation(project(":protokt-reflect"))
+    implementation(kotlin("reflect"))
+    implementation(libs.cel)
+    implementation(libs.protovalidateJava)
+}

protokt-protovalidate/src/main/kotlin/protokt/v1/buf/validate/Validator.kt

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2024 Toast, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package protokt.v1.buf.validate
+
+import build.buf.protovalidate.Config
+import build.buf.protovalidate.ValidationResult
+import build.buf.protovalidate.internal.celext.ValidateLibrary
+import build.buf.protovalidate.internal.evaluator.Evaluator
+import build.buf.protovalidate.internal.evaluator.EvaluatorBuilder
+import build.buf.protovalidate.internal.evaluator.MessageValue
+import com.google.protobuf.Descriptors.Descriptor
+import org.projectnessie.cel.Env
+import org.projectnessie.cel.Library
+import protokt.v1.Beta
+import protokt.v1.GeneratedMessage
+import protokt.v1.Message
+import protokt.v1.google.protobuf.RuntimeContext
+import protokt.v1.google.protobuf.toDynamicMessage
+import java.util.Collections
+import java.util.concurrent.ConcurrentHashMap
+import kotlin.reflect.full.findAnnotation
+
+@Beta
+class Validator @JvmOverloads constructor(
+    config: Config = Config.newBuilder().build()
+) {
+    private val evaluatorBuilder =
+        EvaluatorBuilder(
+            Env.newEnv(Library.Lib(ValidateLibrary())),
+            config.isDisableLazy
+        )
+
+    private val failFast = config.isFailFast
+
+    private val evaluatorsByFullTypeName = ConcurrentHashMap<String, Evaluator>()
+    private val descriptors = Collections.newSetFromMap(ConcurrentHashMap<Descriptor, Boolean>())
+
+    @Volatile
+    private var runtimeContext = RuntimeContext(emptyList())
+
+    fun load(descriptor: Descriptor) {
+        doLoad(descriptor)
+        runtimeContext = RuntimeContext(descriptors)
+    }
+
+    private fun doLoad(descriptor: Descriptor) {
+        descriptors.add(descriptor)
+        evaluatorsByFullTypeName[descriptor.fullName] = evaluatorBuilder.load(descriptor)
+        descriptor.nestedTypes.forEach(::doLoad)
+    }
+
+    fun validate(message: Message): ValidationResult =
+        evaluatorsByFullTypeName
+            .getValue(message::class.findAnnotation<GeneratedMessage>()!!.fullTypeName)
+            .evaluate(MessageValue(message.toDynamicMessage(runtimeContext)), failFast)
+}

settings.gradle.kts

@@ -31,11 +31,12 @@ include(
     "protokt-codegen",
     "protokt-core",
     "protokt-core-lite",
+    "protokt-gradle-plugin",
+    "protokt-protovalidate",
     "protokt-reflect",
     "protokt-runtime",
     "protokt-runtime-grpc",
     "protokt-runtime-grpc-lite",
-    "protokt-gradle-plugin",
 
     "grpc-kotlin-shim",
 
@@ -70,6 +71,7 @@ include(
     "testing:protokt-generation",
     "testing:protokt-generation-2",
     "testing:protobuf-java",
+    "testing:protovalidate-conformance",
     "testing:protobufjs",
     "testing:testing-util",
 

testing/conformance/runner/src/test/kotlin/protokt/v1/conformance/ConformanceTest.kt

@@ -15,10 +15,10 @@
 
 package protokt.v1.conformance
 
+import com.google.common.truth.Truth.assertThat
 import org.junit.jupiter.api.BeforeEach
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.EnumSource
-import protokt.v1.testing.ProcessOutput
 import protokt.v1.testing.projectRoot
 import protokt.v1.testing.runCommand
 import java.io.File
@@ -63,9 +63,15 @@ class ConformanceTest {
     @EnumSource
     fun `run conformance tests`(runner: ConformanceRunner) {
         try {
-            command(runner)
-                .runCommand(projectRoot.toPath())
-                .orFail("Conformance tests failed", ProcessOutput.Src.ERR)
+            val output = command(runner).runCommand(projectRoot.toPath())
+            println(output.stderr)
+
+            assertThat(output.stderr).contains("CONFORMANCE SUITE PASSED")
+            val matches = " (\\d+) unexpected failures".toRegex().findAll(output.stderr).toList()
+            // the current implementation runs two conformance suites
+            assertThat(matches).hasSize(2)
+            matches.forEach { assertThat(it.groupValues[1].toInt()).isEqualTo(0) }
+            assertThat(output.exitCode).isEqualTo(0)
         } catch (t: Throwable) {
             if (failingTests.exists()) {
                 println("Failing tests:\n" + failingTests.readText())

testing/protovalidate-conformance/build.gradle.kts

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2024 Toast, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import com.google.protobuf.gradle.GenerateProtoTask
+import com.google.protobuf.gradle.proto
+import org.gradle.api.distribution.plugins.DistributionPlugin.TASK_INSTALL_NAME
+
+plugins {
+    id("protokt.jvm-conventions")
+    application
+}
+
+localProtokt(false)
+
+dependencies {
+    implementation(project(":protokt-protovalidate"))
+    implementation(project(":protokt-reflect"))
+    implementation(kotlin("reflect"))
+    implementation(libs.cel)
+    implementation(libs.classgraph)
+    implementation(libs.protovalidateJava)
+
+    testImplementation(project(":testing:testing-util"))
+    testImplementation(libs.truth)
+}
+
+sourceSets.main {
+    proto {
+        srcDir(project.layout.buildDirectory.file("protovalidate/export"))
+    }
+}
+
+val protovalidateVersion = libs.versions.protovalidate.get()
+val gobin = project.layout.buildDirectory.file("gobin").get().asFile.absolutePath
+val bufExecutable = project.layout.buildDirectory.file("gobin/buf").get().asFile
+val conformanceExecutable = project.layout.buildDirectory.file("gobin/protovalidate-conformance").get().asFile
+
+val installBuf =
+    tasks.register<Exec>("installBuf") {
+        environment("GOBIN", gobin)
+        outputs.file(bufExecutable)
+        commandLine("go", "install", "github.com/bufbuild/buf/cmd/buf@v${libs.versions.buf.get()}")
+    }
+
+val downloadConformanceProtos =
+    tasks.register<Exec>("downloadConformanceProtos") {
+        dependsOn(installBuf)
+        commandLine(
+            bufExecutable,
+            "export",
+            "buf.build/bufbuild/protovalidate-testing:v$protovalidateVersion",
+            "--output=build/protovalidate/export"
+        )
+    }
+
+tasks.withType<GenerateProtoTask> {
+    dependsOn(downloadConformanceProtos)
+}
+
+val installConformance =
+    tasks.register<Exec>("installProtovalidateConformance") {
+        environment("GOBIN", gobin)
+        outputs.file(conformanceExecutable)
+        commandLine(
+            "go",
+            "install",
+            "github.com/bufbuild/protovalidate/tools/protovalidate-conformance@v$protovalidateVersion"
+        )
+    }
+
+application {
+    mainClass.set("protokt.v1.buf.validate.conformance.Main")
+}
+
+tasks {
+    test {
+        systemProperty("conformance-runner", conformanceExecutable.absolutePath)
+        outputs.upToDateWhen { false }
+        dependsOn(installConformance, TASK_INSTALL_NAME)
+    }
+}

testing/protovalidate-conformance/src/main/kotlin/protokt/v1/buf/validate/conformance/DynamicConcreteMessageDeserializer.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2024 Toast, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package protokt.v1.buf.validate.conformance
+
+import com.google.protobuf.ByteString
+import io.github.classgraph.ClassGraph
+import protokt.v1.Deserializer
+import protokt.v1.GeneratedMessage
+import protokt.v1.google.protobuf.Empty
+import kotlin.reflect.full.findAnnotation
+
+object DynamicConcreteMessageDeserializer {
+    private val deserializersByFullTypeName: Map<String, Deserializer<*>> by lazy {
+        ClassGraph()
+            .enableAnnotationInfo()
+            .acceptPackages(
+                "protokt.v1.buf.validate.conformance.*",
+                "protokt.v1.google.protobuf"
+            )
+            .scan()
+            .use { result ->
+                result.getClassesWithAnnotation(GeneratedMessage::class.java)
+                    .map { it.loadClass().kotlin }
+            }
+            .associate { messageClass ->
+                messageClass.findAnnotation<GeneratedMessage>()!!.fullTypeName to
+                    messageClass
+                        .nestedClasses
+                        .single { it.simpleName == Empty.Deserializer::class.simpleName }
+                        .objectInstance as Deserializer<*>
+            }
+    }
+
+    fun parse(fullTypeName: String, bytes: ByteString) =
+        deserializersByFullTypeName.getValue(fullTypeName).deserialize(bytes.newInput())
+}

testing/protovalidate-conformance/src/main/kotlin/protokt/v1/buf/validate/conformance/FileDescriptorUtil.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2024 Toast, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package protokt.v1.buf.validate.conformance
+
+import com.google.protobuf.DescriptorProtos.FileDescriptorSet
+import com.google.protobuf.Descriptors.Descriptor
+import com.google.protobuf.Descriptors.FileDescriptor
+
+fun parse(fileDescriptorSet: FileDescriptorSet): Map<String, Descriptor> =
+    parseFileDescriptors(fileDescriptorSet)
+        .values
+        .flatMap { fileDescriptor ->
+            fileDescriptor.messageTypes.map { messageType ->
+                messageType.fullName to messageType
+            }
+        }
+        .toMap()
+
+private fun parseFileDescriptors(fileDescriptorSet: FileDescriptorSet): Map<String, FileDescriptor> =
+    fileDescriptorSet.fileList.fold(mutableMapOf()) { map, fileDescriptorProto ->
+        map[fileDescriptorProto.getName()] =
+            FileDescriptor.buildFrom(
+                fileDescriptorProto,
+                fileDescriptorProto.dependencyList.mapNotNull(map::get).toTypedArray(),
+                false
+            )
+        map
+    }