@tahminator/pipeline 1.0.78-beta.3ef6aac5 → 1.0.78

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 clients with the [Buf CLI](https://buf.build/docs/installation/) and its remote plugins. Java and Rust targets can be published to Artifact Keeper with Maven, Gradle, or Cargo. The client installs Buf globally with npm when necessary.
 
 ```ts
 const protobuf = new ProtobufCompilerClient();
@@ -210,32 +210,6 @@ await protobuf.compile({
 });
 ```
 
-Configure generated-code packages in each `.proto` file, not in `targetLanguages`. The client does not enable Buf managed mode; Buf's generators read these file options directly:
-
-```proto
-option go_package = "example.com/proto/helloworld/v1;helloworldv1";
-option java_package = "org.myorg.helloworld.v1";
-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.
-
-For Go publishing, only the release version is needed:
-
-```ts
-targetLanguages: {
-  [ProtobufTargetLanguage.GO]: {
-    version: "1.0.0",
-  },
-},
-```
-
-The publisher generates `go.mod` using the deepest shared directory of the generated Go packages as the module root. For a single package, that package's import path becomes the module path. It never adds, strips, or rewrites version suffixes. Proto authors own package layout; invalid Go module/version combinations fail. In particular, Go does not allow a module path ending in `/v1`. Adding packages outside the existing shared directory changes the inferred module root, so keep the package layout stable across releases.
-
-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.js

@@ -3,8 +3,7 @@ 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 { ArtifactKeeperGoPublisher } from "./go";
+const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
 const DEFAULT_PROST_VERSION = "0.14";
 export class ArtifactKeeperProtobufCompilerBackend {
     config;
@@ -26,11 +25,7 @@ export class ArtifactKeeperProtobufCompilerBackend {
                 });
                 return;
             case ProtobufTargetLanguage.GO:
-                await new ArtifactKeeperGoPublisher(this.config).publish({
-                    generatedDirectory,
-                    options: options,
-                });
-                return;
+                throw new Error("Artifact Keeper Go module publishing requires its upload workflow; only Go module consumption has been configured.");
         }
     }
     async publishJava({ generatedDirectory, options, }) {
@@ -67,12 +62,7 @@ export class ArtifactKeeperProtobufCompilerBackend {
             writeFile(path.join(generatedDirectory, "Cargo.toml"), this.createCargoToml(options)),
             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");
@@ -238,6 +228,6 @@ prost = "${prostVersion}"
         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,7 +8,7 @@ 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]: () => new RustProtobufTargetLanguageStrategy(),
 };
@@ -80,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/java.d.ts

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

package/dist/protobuf/strategy/java.js

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

package/dist/protobuf/types.d.ts

@@ -17,12 +17,10 @@ export interface ProtobufArtifactKeeperBackend {
 }
 export type ProtobufCompilerBackendConfig = ProtobufArtifactKeeperBackend;
 export interface ProtobufJavaTargetLanguageOptions {
-    /** Maven/Gradle publishing group; Java packages are configured in .proto files. */
     groupId: string;
     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 {
@@ -30,8 +28,8 @@ export interface ProtobufRustTargetLanguageOptions {
     version: string;
     prostVersion?: string;
 }
-/** Go import paths are configured with go_package in .proto files. */
 export interface ProtobufGoTargetLanguageOptions {
+    modulePath: string;
     version: string;
 }
 export type ProtobufTargetLanguageOptions = ProtobufGoTargetLanguageOptions | ProtobufJavaTargetLanguageOptions | ProtobufRustTargetLanguageOptions;

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.3ef6aac5",
+  "version": "1.0.78",
   "repository": {
     "url": "git+https://github.com/tahminator/pipeline.git"
   },

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

@@ -1,22 +0,0 @@
-import type { ProtobufArtifactKeeperBackend, ProtobufGoTargetLanguageOptions } from "../types";
-/** Publishes Buf's import-path output as a hosted Go proxy module. */
-export declare class ArtifactKeeperGoPublisher {
-    private readonly config;
-    constructor(config: ProtobufArtifactKeeperBackend);
-    publish({ generatedDirectory, options, }: {
-        generatedDirectory: string;
-        options: ProtobufGoTargetLanguageOptions;
-    }): Promise<void>;
-    private normalizeVersion;
-    private requireToolchains;
-    private inferModulePath;
-    private findPackageDirectories;
-    private validateModuleVersion;
-    private stageModule;
-    private packageModule;
-    private uploadArtifact;
-    private archiveRoot;
-    private escapeProxyPath;
-    private get repositoryUrl();
-    private get shell();
-}

package/dist/protobuf/backend/go.js

@@ -1,149 +0,0 @@
-import { $ } from "bun";
-import { cp, mkdir, mkdtemp, readdir, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import semver from "semver";
-import { isCmdAvailable } from "../../utils/cmd";
-/** Publishes Buf's import-path output as a hosted Go proxy module. */
-export class ArtifactKeeperGoPublisher {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async publish({ generatedDirectory, options, }) {
-        const version = this.normalizeVersion(options.version);
-        await this.requireToolchains();
-        const modulePath = await this.inferModulePath(generatedDirectory);
-        this.validateModuleVersion(modulePath, version);
-        const module = { modulePath, version };
-        const stagingDirectory = await mkdtemp(path.join(tmpdir(), "protobuf-go-"));
-        try {
-            const moduleDirectory = await this.stageModule(module, generatedDirectory, stagingDirectory);
-            const artifacts = await this.packageModule(module, moduleDirectory, stagingDirectory);
-            for (const artifact of artifacts) {
-                await this.uploadArtifact(module, artifact);
-            }
-        }
-        finally {
-            await rm(stagingDirectory, { force: true, recursive: true });
-        }
-    }
-    normalizeVersion(value) {
-        const version = `v${value.replace(/^v/, "")}`;
-        if (!semver.valid(version) || version.includes("+")) {
-            throw new Error("Go publishing requires a semantic version without build metadata.");
-        }
-        return version;
-    }
-    async requireToolchains() {
-        for (const command of ["go", "zip"]) {
-            if (!(await isCmdAvailable(command))) {
-                throw new Error(`Go publishing requires ${command} on PATH.`);
-            }
-        }
-    }
-    async inferModulePath(generatedDirectory) {
-        const packages = await this.findPackageDirectories(generatedDirectory);
-        const prefix = packages[0]?.split("/") ?? [];
-        for (const directory of packages.slice(1)) {
-            const segments = directory.split("/");
-            while (prefix.some((segment, index) => segment !== segments[index])) {
-                prefix.pop();
-            }
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        if (prefix.length < 2 || !prefix[0].includes(".")) {
-            throw new Error("Generated go_package paths must share a module prefix containing a domain and path.");
-        }
-        return prefix.join("/");
-    }
-    async findPackageDirectories(directory, relativeDirectory = "") {
-        const entries = await readdir(directory, { withFileTypes: true });
-        const packages = [];
-        if (entries.some((entry) => entry.isFile() && entry.name.endsWith(".go"))) {
-            packages.push(relativeDirectory);
-        }
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                packages.push(...(await this.findPackageDirectories(path.join(directory, entry.name), relativeDirectory ?
-                    `${relativeDirectory}/${entry.name}`
-                    : entry.name)));
-            }
-        }
-        return packages;
-    }
-    validateModuleVersion(modulePath, version) {
-        const major = semver.major(version);
-        const pathMajor = modulePath.match(/\/v([0-9]+)$/)?.[1] ??
-            (modulePath.startsWith("gopkg.in/") ?
-                modulePath.match(/\.v([0-9]+)$/)?.[1]
-                : undefined);
-        if ((pathMajor &&
-            !modulePath.startsWith("gopkg.in/") &&
-            Number(pathMajor) < 2) ||
-            (pathMajor && Number(pathMajor) !== major) ||
-            (!pathMajor && major >= 2)) {
-            throw new Error(`Go module path ${modulePath} does not match version ${version}.`);
-        }
-    }
-    async stageModule(module, generatedDirectory, stagingDirectory) {
-        // Buf's default paths=import layout includes the full go_package import path.
-        // Strip only the module prefix, without modifying the original output.
-        const sourceDirectory = path.join(generatedDirectory, module.modulePath);
-        const moduleDirectory = path.join(stagingDirectory, this.archiveRoot(module));
-        await mkdir(path.dirname(moduleDirectory), { recursive: true });
-        await cp(sourceDirectory, moduleDirectory, { recursive: true });
-        await this.shell `go mod init ${module.modulePath}`.cwd(moduleDirectory);
-        return moduleDirectory;
-    }
-    async packageModule(module, moduleDirectory, stagingDirectory) {
-        // Resolve dependency metadata; generated code is not linted or tested.
-        await this.shell `go mod tidy`.cwd(moduleDirectory);
-        const archivePath = path.join(stagingDirectory, "module.zip");
-        const archiveRoot = this.archiveRoot(module);
-        await this
-            .shell `zip -q -r ${archivePath} ${archiveRoot} -i ${`${archiveRoot}/*`}`.cwd(stagingDirectory);
-        return [
-            {
-                extension: "mod",
-                filePath: path.join(moduleDirectory, "go.mod"),
-                contentType: "text/plain",
-            },
-            {
-                extension: "zip",
-                filePath: archivePath,
-                contentType: "application/zip",
-            },
-        ];
-    }
-    async uploadArtifact(module, artifact) {
-        const url = `${this.repositoryUrl}/${this.escapeProxyPath(module.modulePath)}/@v/${this.escapeProxyPath(module.version)}.${artifact.extension}`;
-        const credentials = Buffer.from(`${this.config.username}:${this.config.token}`).toString("base64");
-        const response = await fetch(url, {
-            method: "PUT",
-            headers: {
-                Authorization: `Basic ${credentials}`,
-                "Content-Type": artifact.contentType,
-            },
-            body: Bun.file(artifact.filePath),
-            redirect: "error",
-        });
-        await response.body?.cancel();
-        if (!response.ok) {
-            throw new Error(`Go ${artifact.extension} upload failed: HTTP ${response.status}`);
-        }
-    }
-    archiveRoot(module) {
-        return `${module.modulePath}@${module.version}`;
-    }
-    escapeProxyPath(value) {
-        // Go proxy URLs escape uppercase letters; archive entries do not.
-        return value.replace(/[A-Z]/g, (letter) => `!${letter.toLowerCase()}`);
-    }
-    get repositoryUrl() {
-        return `${this.config.url.replace(/\/$/, "")}/go/go`;
-    }
-    get shell() {
-        return $.env({ ...process.env, GOWORK: "off" });
-    }
-}

package/dist/protobuf/versions.d.ts

@@ -1,3 +0,0 @@
-export declare const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.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,13 +0,0 @@
-export const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.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}`;
-}