Taming Dependencies: Micronaut BOM with Gradle Kotlin DSL

syntax = "proto3";
package com.krickert.search.model;
option java_multiple_files = true;
import "google/protobuf/timestamp.proto";
import "google/protobuf/struct.proto";
import "google/protobuf/empty.proto";

message PipeDoc {
  string id = 1;
  string title = 2;
  string body = 3;
  repeated string keywords = 4;
  string document_type = 5;
  string revision_id = 6;
  google.protobuf.Timestamp creation_date = 7;
  google.protobuf.Timestamp last_modified = 8;
  google.protobuf.Struct custom_data = 9;
  SemanticDoc chunk_embeddings = 10;
  map embeddings = 11;
}

message Embedding {
  repeated float embedding = 1;
}

message SemanticDoc {
  string parent_id = 1;
  string parent_field = 2;
  string chunk_config_id = 3;
  string semantic_config_id = 4;
  repeated SemanticChunk chunks = 5;
}

message SemanticChunk {
  string chunk_id = 1;
  int64 chunk_number = 2;
  ChunkEmbedding embedding = 3;
}

message ChunkEmbedding {
  string embedding_text = 1;
  repeated float embedding = 2;
}

message Route {
  RouteType routeType = 1;
  // For Kafka: the topic name; for gRPC: the endpoint tag or destination identifier.
  string destination = 2;
}

enum RouteType {
  UNKNOWN = 0;
  NULL_TERMINATION = 1;
  KAFKA = 2;
  GRPC = 3;
}

message PipeRequest {
  PipeDoc doc = 1;
  map config = 2;
  repeated Route destinations = 3;
}

message OutputResponse {
  bool success = 1;
  oneof reply {
    PipeDoc outputDoc = 2;
    ErrorData errorData = 3;
  }
}

message ErrorData {
  string errorMessage = 2;
  repeated Route failedRoutes = 3;
  optional PipeRequest errorRequest = 4;
}

message PipeResponse {
  bool success = 1;
  optional ErrorData errorDate = 2;
}

message PipeStream {
  PipeRequest request = 1;
  repeated PipeResponse pipeReplies = 2;
  repeated string streamLogs = 3;
}

service PipelineService {
  rpc forward(PipeStream) returns (google.protobuf.Empty);
  rpc getOutput(PipeRequest) returns (OutputResponse);
}
    

var grpcVersion = libs.versions.grpc.get()
var protobufVersion = libs.versions.protobuf.get()

plugins {
    `java-library`
    alias(libs.plugins.protobuf)
}

group = rootProject.group
version = rootProject.version

repositories {
    mavenCentral()
}

java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(21))
    }
}

dependencies {
    implementation(platform(project(":bom")))
    testImplementation(platform(project(":bom")))
    testImplementation(mn.mockito.core)

    implementation(libs.protobuf.java)
    implementation(libs.grpc.protobuf)
    implementation(libs.grpc.stub)
    implementation(libs.slf4j.api)
    implementation(mn.javax.annotation.api)
    implementation(libs.guava)
    implementation(libs.commons.lang3)

    testImplementation(libs.junit.jupiter.api)
    testRuntimeOnly(libs.junit.jupiter.engine)
}

// Simplified protobuf configuration
// Inform IDEs like IntelliJ IDEA, Eclipse or NetBeans about the generated code.
sourceSets {
    main {
        java {
            srcDirs("build/generated/source/proto/main/grpc")
            srcDirs("build/generated/source/proto/main/java")
        }
    }
}

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:$protobufVersion"
    }
    plugins {
        create("grpc") {
            artifact = "io.grpc:protoc-gen-grpc-java:$grpcVersion"
        }
    }
    generateProtoTasks {
        all().forEach { task ->
            task.plugins {
                create("grpc")
            }
        }
    }
}
    

package com.krickert.search.model;

import com.google.protobuf.ListValue;
import com.google.protobuf.Message;
import com.google.protobuf.Timestamp;
import com.google.protobuf.Value;

import java.io.FileOutputStream;
import java.io.IOException;
import java.time.Instant;
import java.util.Collection;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.commons.lang3.StringUtils;


/**
 * Utility class for working with protobuf messages.
 */
public class ProtobufUtils {

    /**
     * Returns the current timestamp as a Timestamp object.
     *
     * @return the current timestamp
     */
    public static Timestamp now() {
        Instant time = Instant.now();
        return Timestamp.newBuilder().setSeconds(time.getEpochSecond())
                .setNanos(time.getNano()).build();
    }

    /**
     * Creates a Timestamp object from the given epoch seconds.
     *
     * @param epochSeconds the number of seconds since January 1, 1970
     * @return a Timestamp object representing the given epoch seconds
     */
    public static Timestamp stamp(long epochSeconds) {
        return Timestamp.newBuilder().setSeconds(epochSeconds)
                .setNanos(0).build();
    }

    /**
     * Saves a Protobuf message to disk.
     *
     * @param dst  The destination file path.
     * @param item The Protobuf message to be saved.
     * @throws IOException If an I/O error occurs while writing to the file.
     */
    public static  void saveProtobufToDisk(String dst, T item) throws IOException {
        item.writeTo(new FileOutputStream(dst));
    }


    /**
     * Saves a collection of Protocol Buffer messages to disk.
     *
     * @param dstPrefix The prefix of the destination file path.
     * @param items     The collection of Protocol Buffer messages to be saved.
     * @param        The type of Protocol Buffer message.
     * @throws RuntimeException If an I/O error occurs while saving the messages.
     */
    public static  void saveProtocoBufsToDisk(String dstPrefix, Collection items) {
        int leftPad = (String.valueOf(items.size())).length();
        saveProtocoBufsToDisk(dstPrefix, items, leftPad);
    }

    /**
     * Saves a collection of Protocol Buffer messages to disk.
     *
     * @param dstPrefix The prefix of the destination file path.
     * @param items     The collection of Protocol Buffer messages to be saved.
     * @param leftPad   The number of digits used for left padding the index of each saved message in the file name.
     * @param        The type of Protocol Buffer message.
     * @throws RuntimeException If an I/O error occurs while saving the messages.
     */
    public static  void saveProtocoBufsToDisk(String dstPrefix, Collection items, int leftPad) {
        AtomicInteger i = new AtomicInteger();
        items.forEach((item) -> {
            try {
                saveProtobufToDisk(dstPrefix + StringUtils.leftPad(String.valueOf(i.getAndIncrement()), leftPad, "0") + ".bin", item);
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
    }

    /**
     * Creates a UUID key from a given string identifier.
     *
     * @param id The string identifier.
     * @return The UUID key.
     */
    public static UUID createKey(String id) {
        return UUID.nameUUIDFromBytes(id.getBytes());
    }

    /**
     * Creates a UUID key from a given PipeDocument object.
     *
     * @param pipeDocument The PipeDocument object to generate the key from.
     * @return The generated UUID key.
     */
    public static UUID createKey(PipeDoc pipeDocument) {
        return createKey(pipeDocument.getId());
    }

    /**
     * Creates a ListValue object from a collection of strings.
     *
     * @param collectionToConvert The collection of strings to be converted.
     * @return A ListValue object containing the converted strings.
     */
    public static ListValue createListValueFromCollection(Collection collectionToConvert) {
        ListValue.Builder builder = ListValue.newBuilder();
        collectionToConvert.forEach((obj) -> builder.addValues(Value.newBuilder().setStringValue(obj).build()));
        return builder.build();
    }
}
    

package com.krickert.search.model;

import com.google.protobuf.ListValue;
import com.google.protobuf.Timestamp;
import com.krickert.search.model.PipeDoc; // Example message
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;


import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Instant;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.UUID;

import static org.junit.jupiter.api.Assertions.*;

class ProtobufUtilsTest {

    // --- Timestamp Tests ---

    /**
     * Tests the {@link ProtobufUtils#now} method.
     * The method should return a {@link Timestamp} object representing the current time
     * as an Instant object, converted to seconds and nanoseconds.
     */
    @Test
    void testNowReturnsCurrentTimestamp() {
        // Act
        Timestamp timestamp = ProtobufUtils.now();

        // Assert
        Instant currentInstant = Instant.now();
        assertNotNull(timestamp);
        assertTrue(timestamp.getSeconds() <= currentInstant.getEpochSecond());
        assertTrue(timestamp.getNanos() >= 0 && timestamp.getNanos() < 1_000_000_000);
        // Allow for a small buffer due to execution time between now() calls
        assertTrue(timestamp.getSeconds() >= (currentInstant.getEpochSecond() - 2), "Timestamp seconds should be very close to current time");
    }

    @Test
    void nowIsNowNotThen() throws InterruptedException {
        Timestamp now1 = ProtobufUtils.now();
        Assertions.assertInstanceOf(Timestamp.class, now1);
        Thread.sleep(10); // Sleep briefly
        Timestamp now2 = ProtobufUtils.now();
        Thread.sleep(1001); // Sleep for over a second
        Timestamp now3 = ProtobufUtils.now();

        assertTrue(now2.getSeconds() >= now1.getSeconds()); // Could be same second
        // If same second, nanos should generally increase (though not guaranteed if clock resolution is low)
        if (now2.getSeconds() == now1.getSeconds()) {
             assertTrue(now2.getNanos() >= now1.getNanos());
        }

        assertTrue(now3.getSeconds() > now1.getSeconds(), "Timestamp after 1s sleep should have larger seconds value");
        assertTrue(now3.getSeconds() > now2.getSeconds());

    }

    @Test
    void stamp() {
        long time = System.currentTimeMillis() / 1000; // Current epoch seconds
        Timestamp stamp = ProtobufUtils.stamp(time);
        assertEquals(time, stamp.getSeconds());
        assertEquals(0, stamp.getNanos());

        Timestamp stampZero = ProtobufUtils.stamp(0);
        assertEquals(0, stampZero.getSeconds());
        assertEquals(0, stampZero.getNanos());

        Timestamp stampNegative = ProtobufUtils.stamp(-1234567890L);
        assertEquals(-1234567890L, stampNegative.getSeconds());
        assertEquals(0, stampNegative.getNanos());
    }

    // --- UUID Tests ---

    @Test
    void createKeyFromString() {
        String id1 = "test-id-1";
        String id2 = "test-id-2";
        String id1Again = "test-id-1";

        UUID key1 = ProtobufUtils.createKey(id1);
        UUID key2 = ProtobufUtils.createKey(id2);
        UUID key1Again = ProtobufUtils.createKey(id1Again);

        assertNotNull(key1);
        assertNotNull(key2);
        assertNotNull(key1Again);

        assertEquals(key1, key1Again); // Same input string -> same UUID
        assertNotEquals(key1, key2);   // Different input string -> different UUID

        // Test empty string
        UUID keyEmpty = ProtobufUtils.createKey("");
        assertNotNull(keyEmpty);

        // Test null string - should throw NullPointerException
        assertThrows(NullPointerException.class, () -> {
            //noinspection DataFlowIssue
            ProtobufUtils.createKey((String) null);
        });
    }

    @Test
    void createKeyFromPipeDoc() {
        PipeDoc doc1 = PipeDoc.newBuilder().setId("doc-id-1").build();
        PipeDoc doc2 = PipeDoc.newBuilder().setId("doc-id-2").build();
        PipeDoc doc1Again = PipeDoc.newBuilder().setId("doc-id-1").setTitle("Different Title").build(); // ID is the same
        PipeDoc docEmptyId = PipeDoc.newBuilder().setId("").build();

        UUID key1 = ProtobufUtils.createKey(doc1);
        UUID key2 = ProtobufUtils.createKey(doc2);
        UUID key1Again = ProtobufUtils.createKey(doc1Again);
        UUID keyEmpty = ProtobufUtils.createKey(docEmptyId);


        assertNotNull(key1);
        assertNotNull(key2);
        assertNotNull(key1Again);
        assertNotNull(keyEmpty);

        assertEquals(key1, key1Again); // Same ID -> same UUID
        assertNotEquals(key1, key2);   // Different ID -> different UUID

        // Test null document - should throw NullPointerException
        assertThrows(NullPointerException.class, () -> {
            //noinspection DataFlowIssue
            ProtobufUtils.createKey((PipeDoc) null);
        });

         // Test document with null ID - should throw NullPointerException when accessing id
         PipeDoc docNullId = PipeDoc.newBuilder().build(); // ID defaults to "", not null technically
         UUID keyFromDefaultEmptyId = ProtobufUtils.createKey(docNullId);
         assertEquals(keyEmpty, keyFromDefaultEmptyId);


    }

    // --- ListValue Test ---
    @Test
    void createListValueFromCollection() {
        Collection strings = Arrays.asList("hello", "world", "", "another");
        ListValue listValue = ProtobufUtils.createListValueFromCollection(strings);

        assertNotNull(listValue);
        assertEquals(4, listValue.getValuesCount());
        assertEquals("hello", listValue.getValues(0).getStringValue());
        assertEquals("world", listValue.getValues(1).getStringValue());
        assertEquals("", listValue.getValues(2).getStringValue());
        assertEquals("another", listValue.getValues(3).getStringValue());

        // Test with empty collection
        ListValue emptyListValue = ProtobufUtils.createListValueFromCollection(Collections.emptyList());
        assertNotNull(emptyListValue);
        assertEquals(0, emptyListValue.getValuesCount());

         // Test with collection containing null - Protobuf Value doesn't allow null strings directly, check behavior
         // The current implementation would likely throw NPE on addValues(Value.newBuilder().setStringValue(null)...)
         Collection listWithNull = Arrays.asList("a", null, "c");
         assertThrows(NullPointerException.class, ()-> ProtobufUtils.createListValueFromCollection(listWithNull), "setStringValue(null) should throw NPE");


        // Test with null collection - should throw NullPointerException
        assertThrows(NullPointerException.class, () -> {
            //noinspection DataFlowIssue
            ProtobufUtils.createListValueFromCollection(null);
        });
    }


    // --- Disk Saving Tests (Requires Temp Directory) ---

    @TempDir
    Path tempDir; // JUnit 5 Temp Directory injection

    @Test
    void saveProtobufToDisk_Single() throws IOException {
        PipeDoc doc = PipeDoc.newBuilder()
                .setId("save-test-1")
                .setTitle("Save Me")
                .build();
        Path filePath = tempDir.resolve("single_doc.bin");
        String dst = filePath.toString();

        ProtobufUtils.saveProtobufToDisk(dst, doc);

        // Verify file exists
        assertTrue(Files.exists(filePath));
        assertTrue(Files.size(filePath) > 0);

        // Verify content can be parsed back
        try (FileInputStream fis = new FileInputStream(dst)) {
            PipeDoc readDoc = PipeDoc.parseFrom(fis);
            assertEquals(doc, readDoc);
        }
    }

    @Test
    void saveProtobufToDisk_Error() {
        PipeDoc doc = PipeDoc.newBuilder().setId("error-test").build();
        String invalidPath = tempDir.resolve("non_existent_dir/file.bin").toString(); // Invalid directory

        // Expect IOException or RuntimeException wrapping it
        assertThrows(IOException.class, () -> ProtobufUtils.saveProtobufToDisk(invalidPath, doc));
    }


    @Test
    void saveProtocoBufsToDisk_Multiple_DefaultPadding() throws IOException {
        PipeDoc doc1 = PipeDoc.newBuilder().setId("multi-1").build();
        PipeDoc doc2 = PipeDoc.newBuilder().setId("multi-2").build();
        List docs = Arrays.asList(doc1, doc2);
        String prefix = tempDir.resolve("multi_default_").toString();

        ProtobufUtils.saveProtocoBufsToDisk(prefix, docs);

        // Check files (padding based on size=2 -> 1 digit)
        Path path1 = tempDir.resolve("multi_default_0.bin");
        Path path2 = tempDir.resolve("multi_default_1.bin");

        assertTrue(Files.exists(path1));
        assertTrue(Files.exists(path2));
        assertEquals(doc1, PipeDoc.parseFrom(Files.readAllBytes(path1)));
        assertEquals(doc2, PipeDoc.parseFrom(Files.readAllBytes(path2)));
    }

    @Test
    void saveProtocoBufsToDisk_Multiple_CustomPadding() throws IOException {
        PipeDoc doc1 = PipeDoc.newBuilder().setId("multi-pad-1").build();
        PipeDoc doc2 = PipeDoc.newBuilder().setId("multi-pad-2").build();
        PipeDoc doc11 = PipeDoc.newBuilder().setId("multi-pad-11").build();
        List docs = Arrays.asList(doc1, doc2, doc11); // Size 3
        String prefix = tempDir.resolve("multi_pad_").toString();
        int leftPad = 3; // Custom padding

        ProtobufUtils.saveProtocoBufsToDisk(prefix, docs, leftPad);

        // Check files with custom padding
        Path path1 = tempDir.resolve("multi_pad_000.bin");
        Path path2 = tempDir.resolve("multi_pad_001.bin");
        Path path3 = tempDir.resolve("multi_pad_002.bin"); // Index 2 for 3rd item

        assertTrue(Files.exists(path1));
        assertTrue(Files.exists(path2));
        assertTrue(Files.exists(path3));
        assertEquals(doc1, PipeDoc.parseFrom(Files.readAllBytes(path1)));
        assertEquals(doc2, PipeDoc.parseFrom(Files.readAllBytes(path2)));
        assertEquals(doc11, PipeDoc.parseFrom(Files.readAllBytes(path3))); // Check 3rd item
    }

     @Test
    void saveProtocoBufsToDisk_EmptyList() throws IOException {
        List docs = Collections.emptyList();
        String prefix = tempDir.resolve("multi_empty_").toString();

        // Should not throw error and not create any files
        ProtobufUtils.saveProtocoBufsToDisk(prefix, docs);

        // Verify no files with the prefix were created
        @SuppressWarnings("resource")
        List files = Files.list(tempDir)
                                .filter(p -> p.getFileName().toString().startsWith("multi_empty_"))
                                .toList();
        assertTrue(files.isEmpty());
    }

}
    

// File: util/build.gradle.kts
plugins {
    `java-library`
}

group = rootProject.group
version = rootProject.version

dependencies {
    implementation(platform(project(":bom")))
    testImplementation(platform(project(":bom")))
    implementation(mn.protobuf.java.util)
    api(libs.guava) // Expose Guava via API

    // Testing dependencies
    testImplementation(libs.junit.jupiter.api)
    testRuntimeOnly(libs.junit.jupiter.engine)
}
    

// File: pipeline-service-core/build.gradle.kts
plugins {
    `java-library`
    `maven-publish`
    alias(libs.plugins.micronaut.library)
}

group = rootProject.group
version = rootProject.version

java {
    withJavadocJar()
    withSourcesJar()
    sourceCompatibility = JavaVersion.VERSION_21
    targetCompatibility = JavaVersion.VERSION_21
}

micronaut {
    version("4.8.2")
    processing {
        incremental(true)
        annotations("com.krickert.search.pipeline.*")
    }
}

dependencies {
    implementation(platform(project(":bom")))
    annotationProcessor(platform(project(":bom")))
    testImplementation(platform(project(":bom")))
    testAnnotationProcessor(platform(project(":bom")))

    // Micronaut dependencies using mn catalog
    annotationProcessor(mn.micronaut.inject.java)
    annotationProcessor(mn.lombok)
    annotationProcessor(mn.micronaut.validation)

    // API dependencies - these are exposed to consumers of the library
    api(mn.micronaut.inject)
    api(mn.micronaut.serde.api)
    api(mn.micronaut.serde.jackson)
    api(mn.micronaut.runtime)
    api(mn.micronaut.validation)
    api(mn.micronaut.grpc.server.runtime)
    api(mn.micronaut.grpc.annotation)
    api(mn.micronaut.kafka)


    // Project dependencies
    api(project(":protobuf-models"))
    api(project(":util"))

    // Implementation dependencies - these are not exposed to consumers
    implementation(libs.slf4j.api)
    compileOnly(mn.lombok)

    // Testing dependencies
    testImplementation(mn.micronaut.test.junit5)
    testAnnotationProcessor(mn.micronaut.inject.java)
}

// Publishing configuration
publishing {
    publications {
        create("mavenJava") {
            from(components["java"])

            pom {
                name.set("Pipeline Service Core")
                description.set("Core library for pipeline service implementation")

                licenses {
                    license {
                        name.set("The Apache License, Version 2.0")
                        url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
                    }
                }
            }
        }
    }
}
    

// File: pipeline-service-test-utils/build.gradle.kts
plugins {
    `java-library`
}

group = rootProject.group
version = rootProject.version

dependencies {
    implementation(platform(project(":bom")))

    // Depend on core library
    api(project(":pipeline-service-core"))

    // Include testing libraries using mn catalog
    api(mn.micronaut.test.junit5)

    // May depend on other utils
    api(project(":util"))
}
    

// pipeline-instance-A/build.gradle.kts
plugins {
    id("java")
    alias(libs.plugins.micronaut.application)
    // id("com.google.cloud.tools.jib") version "..."
}

group = rootProject.group
version = rootProject.version

// Repositories inherited from root project
// Java toolchain inherited from root project

micronaut {
    runtime("netty")
    testRuntime("junit5")
    processing {
        incremental(true)
        annotations("com.krickert.search.pipeline.instanceA.*")
    }
    mainClass("com.krickert.search.pipeline.instanceA.Application")
}

dependencies {
    implementation(platform(project(":bom")))
    annotationProcessor(platform(project(":bom")))
    testImplementation(platform(project(":bom")))
    testAnnotationProcessor(platform(project(":bom")))

    // Micronaut dependencies
    annotationProcessor(mn.micronaut.inject.java)
    implementation(mn.micronaut.inject)
    implementation(mn.micronaut.runtime)
    implementation(mn.micronaut.http.server.netty)
    implementation(mn.micronaut.http.client)
    implementation(mn.micronaut.jackson.databind)

    // Project dependencies
    implementation(project(":pipeline-service-core"))

    // Logging implementation
    runtimeOnly(libs.slf4j.simple)

    // Testing
    testImplementation(mn.micronaut.test.junit5) // Micronaut test pulls in JUnit
    // testImplementation(libs.bundles.testing.jvm) // Removed bundle
    testImplementation(project(":pipeline-service-test-utils"))
    testAnnotationProcessor(mn.micronaut.inject.java)
}

application {
    mainClass.set(micronaut.mainClass.get())
}

// Test task configuration inherited from root project