@tahminator/pipeline 1.0.78-beta.1e2228eb → 1.0.78-beta.1fe28066

package/README.md

@@ -185,7 +185,7 @@ await client.promoteDockerImage({
 
 ### `ProtobufCompilerClient`
 
-Generate protobuf clients with the [Buf CLI](https://buf.build/docs/installation/) and its remote plugins. Java, Rust, and Go targets can be published to Artifact Keeper with Maven/Gradle, Cargo, or Go module uploads. The client installs Buf globally with npm when necessary.
+Generate protobuf messages and gRPC client/server stubs with the [Buf CLI](https://buf.build/docs/installation/) and its remote plugins. Java, Rust, and Go targets can be published to Artifact Keeper with Maven/Gradle, Cargo, or Go module uploads. The client installs Buf globally with npm when necessary.
 
 ```ts
 const protobuf = new ProtobufCompilerClient();
@@ -220,6 +220,20 @@ option java_multiple_files = true;
 
 `go_package` is required for Go generation with this client. Java package options are recommended; `java_outer_classname` is optional. Rust generation needs no language-specific file options. CI target options such as Java `groupId`/`artifactId` and Rust `crateName` are publishing metadata, not generated-code package names. Go's former unused `modulePath` option has been removed.
 
+Every target enables both message and service generation by default:
+
+| Target                  | Generated service API                                                | Published runtime dependencies                      |
+| ----------------------- | -------------------------------------------------------------------- | --------------------------------------------------- |
+| Java (Maven and Gradle) | `<Service>Grpc.<Service>ImplBase` and client stubs                   | `protobuf-java`, `grpc-protobuf`, `grpc-stub`       |
+| Go                      | `<Service>Server`, `Unimplemented<Service>Server`, `<Service>Client` | Resolved by `go mod tidy` into the generated module |
+| Rust                    | Tonic `<service>_server` traits and `<service>_client` clients       | `prost`, `prost-types`, `tonic`, `tonic-prost`      |
+
+Applications implement the generated service interfaces and supply server startup, endpoints, authentication, and transport configuration. Java applications must add a transport implementation such as `io.grpc:grpc-netty-shaded:1.75.0`; the generated SDK does not choose one. Gradle publishes public runtime types as `api` dependencies so they are visible on consumers' compile classpaths.
+
+Imported schemas are generated alongside the selected input, except standard well-known types, which use the runtime libraries. This produces self-contained schema output rather than relying on separately published schema packages. Go publishing still requires those package paths to share a valid module root.
+
+Rust's Prost and Tonic plugins are pinned to `v0.5.0`, paired with the `0.14` runtime series. `prostVersion` overrides must remain within `0.14`. The published crate preserves proto package hierarchy (for example, `example.v1` becomes `example::v1`) and includes Tonic stubs in the same module as their messages. This replaces the previous flattened Rust module names.
+
 For Go publishing, only the release version is needed:
 
 ```ts

package/dist/protobuf/backend/artifact-keeper.d.ts

@@ -14,7 +14,6 @@ export declare class ArtifactKeeperProtobufCompilerBackend implements IProtobufC
     private createMavenSettings;
     private createGradleBuild;
     private createCargoToml;
-    private createRustLibrary;
     private escapeXml;
     private get artifactKeeperUrl();
     private get mavenRepositoryUrl();

package/dist/protobuf/backend/artifact-keeper.js

@@ -3,9 +3,9 @@ import { mkdir, mkdtemp, readdir, rename, rm, writeFile, } from "node:fs/promise
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { ProtobufTargetLanguage, } from "../types";
-import { DEFAULT_PROTOBUF_JAVA_VERSION } from "../versions";
+import { DEFAULT_PROTOBUF_JAVA_VERSION, DEFAULT_PROST_VERSION, GRPC_JAVA_VERSION, TONIC_VERSION, } from "../versions";
 import { ArtifactKeeperGoPublisher } from "./go";
-const DEFAULT_PROST_VERSION = "0.14";
+import { createRustLibrary } from "./rust-library";
 export class ArtifactKeeperProtobufCompilerBackend {
     config;
     constructor(config) {
@@ -65,7 +65,7 @@ export class ArtifactKeeperProtobufCompilerBackend {
         await mkdir(path.join(generatedDirectory, "src"), { recursive: true });
         await Promise.all([
             writeFile(path.join(generatedDirectory, "Cargo.toml"), this.createCargoToml(options)),
-            writeFile(path.join(generatedDirectory, "src", "lib.rs"), this.createRustLibrary(generatedFiles)),
+            writeFile(path.join(generatedDirectory, "src", "lib.rs"), createRustLibrary(generatedFiles)),
         ]);
         await $.env({
             ...process.env,
@@ -124,6 +124,22 @@ export class ArtifactKeeperProtobufCompilerBackend {
       <artifactId>protobuf-java</artifactId>
       <version>${this.escapeXml(protobufVersion)}</version>
     </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-protobuf</artifactId>
+      <version>${GRPC_JAVA_VERSION}</version>
+    </dependency>
+    <dependency>
+      <groupId>io.grpc</groupId>
+      <artifactId>grpc-stub</artifactId>
+      <version>${GRPC_JAVA_VERSION}</version>
+    </dependency>
+    <dependency>
+      <groupId>javax.annotation</groupId>
+      <artifactId>javax.annotation-api</artifactId>
+      <version>1.3.2</version>
+      <scope>provided</scope>
+    </dependency>
   </dependencies>
   <distributionManagement>
     <repository>
@@ -149,7 +165,7 @@ export class ArtifactKeeperProtobufCompilerBackend {
     createGradleBuild(options) {
         const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
         return `plugins {
-    id "java"
+    id "java-library"
     id "maven-publish"
 }
 
@@ -161,7 +177,10 @@ repositories {
 }
 
 dependencies {
-    implementation "com.google.protobuf:protobuf-java:${protobufVersion}"
+    api "com.google.protobuf:protobuf-java:${protobufVersion}"
+    api "io.grpc:grpc-protobuf:${GRPC_JAVA_VERSION}"
+    api "io.grpc:grpc-stub:${GRPC_JAVA_VERSION}"
+    compileOnly "javax.annotation:javax.annotation-api:1.3.2"
 }
 
 java {
@@ -199,21 +218,10 @@ edition = "2021"
 [dependencies]
 prost = "${prostVersion}"
 prost-types = "${prostVersion}"
+tonic = "${TONIC_VERSION}"
+tonic-prost = "${TONIC_VERSION}"
 `;
     }
-    createRustLibrary(generatedFiles) {
-        return generatedFiles
-            .map((relativePath) => {
-            const moduleName = relativePath
-                .replace(/\.rs$/, "")
-                .replace(/[^a-zA-Z0-9_]/g, "_");
-            return `pub mod ${moduleName} {
-    include!(concat!(env!("CARGO_MANIFEST_DIR"), "/${relativePath}"));
-}
-`;
-        })
-            .join("\n");
-    }
     escapeXml(value) {
         return value.replace(/[<>&'"]/g, (character) => {
             switch (character) {

package/dist/protobuf/backend/rust-library.d.ts

@@ -0,0 +1,2 @@
+/** Prost filenames encode proto packages; Tonic belongs in the same module. */
+export declare function createRustLibrary(generatedFiles: string[]): string;

package/dist/protobuf/backend/rust-library.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+/** Prost filenames encode proto packages; Tonic belongs in the same module. */
+export function createRustLibrary(generatedFiles) {
+    const root = { files: [], children: new Map() };
+    for (const file of [...generatedFiles].sort()) {
+        const packageName = path.posix
+            .basename(file)
+            .replace(/(?:\.tonic)?\.rs$/, "");
+        let node = root;
+        for (const segment of packageName === "_" ? [] : packageName.split(".")) {
+            if (!/^(?:r#)?[a-zA-Z_][a-zA-Z0-9_]*$/.test(segment) ||
+                ["self", "Self", "super", "crate"].includes(segment)) {
+                throw new Error(`Cannot represent Rust package module ${segment} from ${file}.`);
+            }
+            const name = segment.startsWith("r#") ? segment : `r#${segment}`;
+            let child = node.children.get(name);
+            if (!child) {
+                child = { files: [], children: new Map() };
+                node.children.set(name, child);
+            }
+            node = child;
+        }
+        node.files.push(file);
+    }
+    function render(node, indent = "") {
+        const includes = node.files
+            .map((file) => `${indent}include!(concat!(env!("CARGO_MANIFEST_DIR"), ${JSON.stringify(`/${file}`)}));\n`)
+            .join("");
+        const children = [...node.children]
+            .map(([name, child]) => `${indent}pub mod ${name} {\n${render(child, `${indent}    `)}${indent}}\n`)
+            .join("");
+        return includes + children;
+    }
+    return render(root);
+}

package/dist/protobuf/client.js

@@ -10,7 +10,7 @@ import { ProtobufTargetLanguage, } from "./types";
 const TARGET_LANGUAGE_STRATEGY_FACTORIES = {
     [ProtobufTargetLanguage.JAVA]: (targets) => new JavaProtobufTargetLanguageStrategy(targets[ProtobufTargetLanguage.JAVA]?.protobufJavaVersion),
     [ProtobufTargetLanguage.GO]: () => new GoProtobufTargetLanguageStrategy(),
-    [ProtobufTargetLanguage.RUST]: () => new RustProtobufTargetLanguageStrategy(),
+    [ProtobufTargetLanguage.RUST]: (targets) => new RustProtobufTargetLanguageStrategy(targets[ProtobufTargetLanguage.RUST]?.prostVersion),
 };
 export class ProtobufCompilerClient {
     async compile({ backend, bufToken, targetLanguages, protoFilesLocation, outputDirectory, }) {
@@ -58,10 +58,11 @@ export class ProtobufCompilerClient {
         const pathFlag = pathFilter ? ["--path", pathFilter] : [];
         await writeFile(templatePath, yaml.stringify({
             version: "v2",
-            plugins: targetStrategies.map((strategy) => ({
+            plugins: targetStrategies.flatMap((strategy) => strategy.plugins.map((plugin) => ({
+                ...plugin,
                 out: strategy.outputDirectoryName,
-                remote: strategy.remotePlugin,
-            })),
+                include_imports: true,
+            }))),
         }));
         try {
             const command = bufToken ?

package/dist/protobuf/strategy/go.d.ts

@@ -1,5 +1,7 @@
 import type { IProtobufTargetLanguageStrategy } from "./types";
 export declare class GoProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName = "go";
-    readonly remotePlugin = "buf.build/protocolbuffers/go";
+    readonly plugins: {
+        remote: string;
+    }[];
 }

package/dist/protobuf/strategy/go.js

@@ -1,4 +1,7 @@
 export class GoProtobufTargetLanguageStrategy {
     outputDirectoryName = "go";
-    remotePlugin = "buf.build/protocolbuffers/go";
+    plugins = [
+        { remote: "buf.build/protocolbuffers/go:v1.36.11" },
+        { remote: "buf.build/grpc/go:v1.5.1" },
+    ];
 }

package/dist/protobuf/strategy/java.d.ts

@@ -1,6 +1,8 @@
 import type { IProtobufTargetLanguageStrategy } from "./types";
 export declare class JavaProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName = "java";
-    readonly remotePlugin: string;
+    readonly plugins: {
+        remote: string;
+    }[];
     constructor(runtimeVersion?: string);
 }

package/dist/protobuf/strategy/java.js

@@ -1,8 +1,13 @@
-import { DEFAULT_PROTOBUF_JAVA_VERSION, javaGeneratorVersion, } from "../versions";
+import { DEFAULT_PROTOBUF_JAVA_VERSION, GRPC_JAVA_VERSION, javaGeneratorVersion, } from "../versions";
 export class JavaProtobufTargetLanguageStrategy {
     outputDirectoryName = "java";
-    remotePlugin;
+    plugins;
     constructor(runtimeVersion = DEFAULT_PROTOBUF_JAVA_VERSION) {
-        this.remotePlugin = `buf.build/protocolbuffers/java:v${javaGeneratorVersion(runtimeVersion)}`;
+        this.plugins = [
+            {
+                remote: `buf.build/protocolbuffers/java:v${javaGeneratorVersion(runtimeVersion)}`,
+            },
+            { remote: `buf.build/grpc/java:v${GRPC_JAVA_VERSION}` },
+        ];
     }
 }

package/dist/protobuf/strategy/rust.d.ts

@@ -1,5 +1,12 @@
 import type { IProtobufTargetLanguageStrategy } from "./types";
 export declare class RustProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName = "rust";
-    readonly remotePlugin = "buf.build/community/neoeinstein-prost";
+    readonly plugins: ({
+        remote: string;
+        opt?: undefined;
+    } | {
+        remote: string;
+        opt: string[];
+    })[];
+    constructor(prostVersion?: string);
 }

package/dist/protobuf/strategy/rust.js

@@ -1,4 +1,21 @@
+import semver from "semver";
+import { DEFAULT_PROST_VERSION, PROST_PLUGIN_VERSION } from "../versions";
 export class RustProtobufTargetLanguageStrategy {
     outputDirectoryName = "rust";
-    remotePlugin = "buf.build/community/neoeinstein-prost";
+    plugins = [
+        {
+            remote: `buf.build/community/neoeinstein-prost:v${PROST_PLUGIN_VERSION}`,
+        },
+        {
+            remote: `buf.build/community/neoeinstein-tonic:v${PROST_PLUGIN_VERSION}`,
+            // lib.rs includes messages and service stubs into the same package module.
+            opt: ["no_include=true"],
+        },
+    ];
+    constructor(prostVersion = DEFAULT_PROST_VERSION) {
+        if (!semver.validRange(prostVersion) ||
+            !semver.subset(prostVersion, ">=0.14.0 <0.15.0")) {
+            throw new Error("The pinned Rust gRPC generators require prostVersion in the 0.14 release series.");
+        }
+    }
 }

package/dist/protobuf/strategy/types.d.ts

@@ -1,4 +1,8 @@
+export interface ProtobufGeneratorPlugin {
+    readonly remote: string;
+    readonly opt?: string[];
+}
 export interface IProtobufTargetLanguageStrategy {
     readonly outputDirectoryName: string;
-    readonly remotePlugin: string;
+    readonly plugins: ProtobufGeneratorPlugin[];
 }

package/dist/protobuf/types.d.ts

@@ -28,6 +28,7 @@ export interface ProtobufJavaTargetLanguageOptions {
 export interface ProtobufRustTargetLanguageOptions {
     crateName: string;
     version: string;
+    /** Prost runtime constraint within 0.14; matched to the pinned Prost/Tonic generators. */
     prostVersion?: string;
 }
 /** Go import paths are configured with go_package in .proto files. */

package/dist/protobuf/versions.d.ts

@@ -1,3 +1,7 @@
 export declare const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
+export declare const GRPC_JAVA_VERSION = "1.75.0";
+export declare const PROST_PLUGIN_VERSION = "0.5.0";
+export declare const DEFAULT_PROST_VERSION = "0.14.1";
+export declare const TONIC_VERSION = "0.14.1";
 /** Java runtime releases include a language major absent from modern protoc tags. */
 export declare function javaGeneratorVersion(runtimeVersion: string): string;

package/dist/protobuf/versions.js

@@ -1,4 +1,8 @@
 export const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
+export const GRPC_JAVA_VERSION = "1.75.0";
+export const PROST_PLUGIN_VERSION = "0.5.0";
+export const DEFAULT_PROST_VERSION = "0.14.1";
+export const TONIC_VERSION = "0.14.1";
 /** Java runtime releases include a language major absent from modern protoc tags. */
 export function javaGeneratorVersion(runtimeVersion) {
     const match = /^(3|4)\.(\d+)\.(\d+)$/.exec(runtimeVersion);

package/package.json

@@ -3,7 +3,7 @@
   "type": "module",
   "author": "Tahmid Ahmed",
   "description": "A collection of Bun shell scripts that can be re-used in various CICD pipelines.",
-  "version": "1.0.78-beta.1e2228eb",
+  "version": "1.0.78-beta.1fe28066",
   "repository": {
     "url": "git+https://github.com/tahminator/pipeline.git"
   },