@tahminator/pipeline 1.0.78-beta.1fe28066 → 1.0.78-beta.2a7182af

package/README.md

@@ -185,7 +185,7 @@ await client.promoteDockerImage({
 
 ### `ProtobufCompilerClient`
 
-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.
+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.
 
 ```ts
 const protobuf = new ProtobufCompilerClient();
@@ -220,20 +220,6 @@ 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
@@ -248,8 +234,6 @@ The publisher generates `go.mod` using the deepest shared directory of the gener
 
 Go publishing requires `go` and `zip` on PATH. It stages generated packages without changing the original output, runs `go mod init` and `go mod tidy` to generate dependency metadata, and uploads `.mod` and `.zip` artifacts to the hosted `go` repository at `<backend.url>/go/go`. It does not lint, build, or test generated code. Dependency resolution may require network access. Versions may include a leading `v`; v2+ modules require the corresponding major-version module path suffix.
 
-Java generation is pinned to the compiler release matching `protobufJavaVersion` (default runtime `4.32.1`, Buf Java plugin `v32.1`). The same runtime version is used in both Maven and Gradle metadata. Overrides must be exact stable versions, not ranges, and the corresponding plugin must exist in the Buf registry.
-
 ### `NPMClient`
 
 Interface with NPM registry in order to publish packages to `npmjs.com`

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

@@ -14,6 +14,7 @@ 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, DEFAULT_PROST_VERSION, GRPC_JAVA_VERSION, TONIC_VERSION, } from "../versions";
 import { ArtifactKeeperGoPublisher } from "./go";
-import { createRustLibrary } from "./rust-library";
+const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
+const DEFAULT_PROST_VERSION = "0.14";
 export class ArtifactKeeperProtobufCompilerBackend {
     config;
     constructor(config) {
@@ -65,14 +65,9 @@ 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"), createRustLibrary(generatedFiles)),
+            writeFile(path.join(generatedDirectory, "src", "lib.rs"), this.createRustLibrary(generatedFiles)),
         ]);
-        await $.env({
-            ...process.env,
-            CARGO_REGISTRIES_CARGO_INDEX: this.cargoIndexUrl,
-            CARGO_REGISTRIES_CARGO_TOKEN: this.config.token,
-            CARGO_REGISTRIES_CARGO_CREDENTIAL_PROVIDER: "cargo:token",
-        }) `cargo publish --registry cargo`.cwd(generatedDirectory);
+        await $ `cargo publish --registry cargo --token ${this.config.token} --config ${`registries.cargo.index=${this.cargoIndexUrl}`}`.cwd(generatedDirectory);
     }
     async moveJavaSources(generatedDirectory) {
         const sourceDirectory = path.join(generatedDirectory, "src", "main", "java");
@@ -124,22 +119,6 @@ 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>
@@ -165,7 +144,7 @@ export class ArtifactKeeperProtobufCompilerBackend {
     createGradleBuild(options) {
         const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
         return `plugins {
-    id "java-library"
+    id "java"
     id "maven-publish"
 }
 
@@ -177,10 +156,7 @@ repositories {
 }
 
 dependencies {
-    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"
+    implementation "com.google.protobuf:protobuf-java:${protobufVersion}"
 }
 
 java {
@@ -217,11 +193,21 @@ 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) {
@@ -247,6 +233,6 @@ tonic-prost = "${TONIC_VERSION}"
         return `${this.artifactKeeperUrl}/maven/maven/`;
     }
     get cargoIndexUrl() {
-        return `sparse+${this.artifactKeeperUrl}/cargo/cargo/`;
+        return `${this.artifactKeeperUrl}/cargo/cargo/index`;
     }
 }

package/dist/protobuf/client.js

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

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

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

package/dist/protobuf/strategy/go.js

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

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

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

package/dist/protobuf/strategy/java.js

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

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

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

package/dist/protobuf/strategy/rust.js

@@ -1,21 +1,4 @@
-import semver from "semver";
-import { DEFAULT_PROST_VERSION, PROST_PLUGIN_VERSION } from "../versions";
 export class RustProtobufTargetLanguageStrategy {
     outputDirectoryName = "rust";
-    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.");
-        }
-    }
+    remotePlugin = "buf.build/community/neoeinstein-prost";
 }

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

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

package/dist/protobuf/types.d.ts

@@ -22,13 +22,11 @@ export interface ProtobufJavaTargetLanguageOptions {
     artifactId: string;
     version: string;
     buildTool?: "maven" | "gradle";
-    /** Exact stable Java runtime version; also pins the matching Buf generator. Defaults to 4.32.1. */
     protobufJavaVersion?: string;
 }
 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/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.1fe28066",
+  "version": "1.0.78-beta.2a7182af",
   "repository": {
     "url": "git+https://github.com/tahminator/pipeline.git"
   },

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

@@ -1,2 +0,0 @@
-/** 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

@@ -1,35 +0,0 @@
-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/versions.d.ts

@@ -1,7 +0,0 @@
-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,17 +0,0 @@
-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);
-    if (!match) {
-        throw new Error("protobufJavaVersion must be an exact stable 3.x or 4.x version.");
-    }
-    const [, major, minor, patch] = match;
-    // Before protoc 21, compiler and Java runtime used the same 3.x version.
-    return major === "3" && Number(minor) < 21 ?
-        runtimeVersion
-        : `${minor}.${patch}`;
-}