@tahminator/pipeline 1.0.76 → 1.0.77

package/README.md

@@ -38,6 +38,10 @@ import {
   EnvClient,
   GitHubClient,
   NPMClient,
+  ProtobufCompilerBackend,
+  ProtobufCompilerClient,
+  ProtobufSourceLanguage,
+  ProtobufTargetLanguage,
   PulumiClient,
   SonarScannerClient,
   Utils,
@@ -53,6 +57,7 @@ Jump to client documentation
 
 - [`GitHubClient`](#githubclient)
 - [`DockerClient`](#dockerclient)
+- [`ProtobufCompilerClient`](#protobufcompilerclient)
 - [`NPMClient`](#npmclient)
 - [`SonarScannerClient`](#sonarscannerclient)
 - [`Utils`](#utils)
@@ -178,6 +183,33 @@ await client.promoteDockerImage({
 });
 ```
 
+### `ProtobufCompilerClient`
+
+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();
+
+await protobuf.compile({
+  backend: {
+    type: ProtobufCompilerBackend.ARTIFACT_KEEPER,
+    token: process.env.ARTIFACT_KEEPER_TOKEN!,
+    url: process.env.ARTIFACT_KEEPER_URL!,
+    username: process.env.ARTIFACT_KEEPER_USERNAME!,
+  },
+  sourceLanguage: ProtobufSourceLanguage.RUST,
+  bufToken: process.env.BUF_TOKEN,
+  targetLanguages: {
+    [ProtobufTargetLanguage.JAVA]: {
+      artifactId: "hello-world-grpc-service",
+      groupId: "org.my-org",
+      version: "1.0.0",
+    },
+  },
+  protoFilesLocation: "./proto",
+});
+```
+
 ### `NPMClient`
 
 Interface with NPM registry in order to publish packages to `npmjs.com`
@@ -360,6 +392,7 @@ Utilities to compute the next semver tag from GitHub and update versions in code
 ```ts
 const gh = await GitHubClient.createWithDefaultCiToken();
 
+// available strategies: JSTS, JAVA_MAVEN, RUST_CARGO, NONE
 const versioning = new VersioningClient(gh, VersionUpdatingStrategy.JSTS);
 
 // if your repo has no tags yet, this will return `1.0.0`

package/dist/gh/client.d.ts

@@ -118,6 +118,13 @@ export declare class GitHubClient {
         pull_requests: import("@octokit/openapi-types").components["schemas"]["pull-request-minimal"][];
         deployment?: import("@octokit/openapi-types").components["schemas"]["deployment-simple"];
     } | null>;
+    /**
+     * Uploads a local directory into a repository path using the authenticated GitHub API.
+     * Existing files under `directory` that are not present locally are deleted.
+     *
+     * **PLEASE DO NOT USE THIS FUNCTION UNLESS YOU KNOW WHAT YOU ARE DOING.**
+     */
+    DANGEROUS__uploadDirectoryContents(...args: Parameters<GitHubPRManager["uploadDirectoryContents"]>): Promise<void>;
     /**
      * Confirms whether the given user is an active member of a team within an org.
      *

package/dist/gh/client.js

@@ -126,6 +126,15 @@ export class GitHubClient {
     statusCheck(...args) {
         return this.prManager.statusCheck(...args);
     }
+    /**
+     * Uploads a local directory into a repository path using the authenticated GitHub API.
+     * Existing files under `directory` that are not present locally are deleted.
+     *
+     * **PLEASE DO NOT USE THIS FUNCTION UNLESS YOU KNOW WHAT YOU ARE DOING.**
+     */
+    DANGEROUS__uploadDirectoryContents(...args) {
+        return this.prManager.uploadDirectoryContents(...args);
+    }
     /**
      * Confirms whether the given user is an active member of a team within an org.
      *

package/dist/gh/pr/index.d.ts

@@ -7,6 +7,14 @@ type CheckRunOutput = {
     summary: string;
     text?: string;
 };
+type UploadDirectoryContentsArgs = {
+    owner: string;
+    repository: string;
+    sourceDirectory: string;
+    directory?: string;
+    message?: string;
+    branch?: string;
+};
 type StatusCheckArgs = {
     action: "create";
     owner: string;
@@ -42,6 +50,7 @@ type StatusCheckArgs = {
 export declare class GitHubPRManager {
     private readonly client;
     constructor(client: Octokit);
+    uploadDirectoryContents({ owner, repository, sourceDirectory, directory, message, branch, }: UploadDirectoryContentsArgs): Promise<void>;
     updateK8sTagWithPR({ newTag, imageName, kustomizationFilePath, environment, originRepo, manifestRepo, }: {
         newTag: string;
         imageName: string;
@@ -89,5 +98,9 @@ export declare class GitHubPRManager {
         repository: string;
         message: string;
     }): Promise<void>;
+    private createDirectoryTree;
+    private createDirectoryBlobEntries;
+    private getDirectoryPathPrefix;
+    private collectDirectoryFiles;
 }
 export {};

package/dist/gh/pr/index.js

@@ -1,3 +1,5 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
 import yaml from "yaml";
 import { Utils } from "../../utils";
 import { kustomizeSchema } from "./schema";
@@ -6,6 +8,47 @@ export class GitHubPRManager {
     constructor(client) {
         this.client = client;
     }
+    async uploadDirectoryContents({ owner, repository, sourceDirectory, directory = "", message = "chore: update generated files", branch, }) {
+        const { data: repo } = await this.client.rest.repos.get({
+            owner,
+            repo: repository,
+        });
+        const targetBranch = branch ?? repo.default_branch;
+        const { data: ref } = await this.client.rest.git.getRef({
+            owner,
+            repo: repository,
+            ref: `heads/${targetBranch}`,
+        });
+        const { data: baseCommit } = await this.client.rest.git.getCommit({
+            owner,
+            repo: repository,
+            commit_sha: ref.object.sha,
+        });
+        const treeSha = await this.createDirectoryTree({
+            directory,
+            owner,
+            repository,
+            sourceDirectory,
+            baseTreeSha: baseCommit.tree.sha,
+        });
+        if (treeSha === baseCommit.tree.sha) {
+            console.log("No directory changes to upload.");
+            return;
+        }
+        const { data: commit } = await this.client.rest.git.createCommit({
+            owner,
+            repo: repository,
+            message,
+            tree: treeSha,
+            parents: [ref.object.sha],
+        });
+        await this.client.rest.git.updateRef({
+            owner,
+            repo: repository,
+            ref: `heads/${targetBranch}`,
+            sha: commit.sha,
+        });
+    }
     async updateK8sTagWithPR({ newTag, imageName, kustomizationFilePath, environment, originRepo, manifestRepo, }) {
         const [manifestOwner, manifestRepository] = manifestRepo;
         const [originOwner, originRepository] = originRepo;
@@ -131,4 +174,84 @@ export class GitHubPRManager {
             body: message,
         });
     }
+    async createDirectoryTree({ owner, repository, sourceDirectory, directory, baseTreeSha, }) {
+        const pathPrefix = this.getDirectoryPathPrefix(directory);
+        const files = await this.collectDirectoryFiles(sourceDirectory);
+        const localPaths = new Set(files.map(({ relativePath }) => `${pathPrefix}${relativePath}`));
+        const { data: existingTree } = await this.client.rest.git.getTree({
+            owner,
+            repo: repository,
+            tree_sha: baseTreeSha,
+            recursive: "true",
+        });
+        const deletionEntries = existingTree.tree.flatMap((entry) => {
+            if (entry.type !== "blob" ||
+                !entry.path?.startsWith(pathPrefix) ||
+                localPaths.has(entry.path)) {
+                return [];
+            }
+            return [
+                {
+                    path: entry.path,
+                    mode: "100644",
+                    type: "blob",
+                    sha: null,
+                },
+            ];
+        });
+        const blobEntries = await this.createDirectoryBlobEntries({
+            files,
+            owner,
+            repository,
+            pathPrefix,
+        });
+        const { data: tree } = await this.client.rest.git.createTree({
+            owner,
+            repo: repository,
+            base_tree: baseTreeSha,
+            tree: [...deletionEntries, ...blobEntries],
+        });
+        return tree.sha;
+    }
+    async createDirectoryBlobEntries({ owner, repository, files, pathPrefix, }) {
+        return Promise.all(files.map(async ({ absolutePath, relativePath }) => {
+            const content = await readFile(absolutePath);
+            const { data: blob } = await this.client.rest.git.createBlob({
+                owner,
+                repo: repository,
+                content: content.toString("base64"),
+                encoding: "base64",
+            });
+            return {
+                path: `${pathPrefix}${relativePath}`,
+                mode: "100644",
+                type: "blob",
+                sha: blob.sha,
+            };
+        }));
+    }
+    getDirectoryPathPrefix(directory) {
+        const normalizedDirectory = directory.replace(/^\/+|\/+$/g, "");
+        return normalizedDirectory ? `${normalizedDirectory}/` : "";
+    }
+    async collectDirectoryFiles(directory, baseDirectory = directory) {
+        const files = [];
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const absolutePath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                files.push(...(await this.collectDirectoryFiles(absolutePath, baseDirectory)));
+                continue;
+            }
+            if (entry.isFile()) {
+                files.push({
+                    absolutePath,
+                    relativePath: path
+                        .relative(baseDirectory, absolutePath)
+                        .split(path.sep)
+                        .join("/"),
+                });
+            }
+        }
+        return files;
+    }
 }

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./docker";
 export * from "./npm";
 export * from "./sonar";
 export * from "./pulumi";
+export * from "./protobuf";
 export * from "./types";
 export * from "./env";
 export * from "./postgres";

package/dist/index.js

@@ -3,6 +3,7 @@ export * from "./docker";
 export * from "./npm";
 export * from "./sonar";
 export * from "./pulumi";
+export * from "./protobuf";
 export * from "./types";
 export * from "./env";
 export * from "./postgres";

package/dist/internal/create-tag/index.js

@@ -1,14 +1,11 @@
-import { EnvClient, EnvClientStrategy } from "../../env";
 import { GitHubClient } from "../../gh";
-import { Utils } from "../../utils";
 import { VersioningClient, VersionUpdatingStrategy } from "../../versioning";
 async function main() {
-    const envClient = EnvClient.create(EnvClientStrategy.GIT_CRYPT);
-    const { githubAppAppId, githubAppInstallationId, githubAppPrivateKeyB64 } = parseCiEnv(await envClient.readFromEnv(".env.ci"));
+    const { githubAppAppId, githubAppInstallationId, githubAppPrivateKey } = parseCiEnv(process.env);
     const ghClient = await GitHubClient.createWithGithubAppToken({
         appId: githubAppAppId,
         installationId: githubAppInstallationId,
-        privateKey: await Utils.decodeBase64EncodedString(githubAppPrivateKeyB64),
+        privateKey: githubAppPrivateKey,
     });
     const versioningClient = new VersioningClient(ghClient, VersionUpdatingStrategy.JSTS);
     const rootPkgJson = await Bun.file("./package.json").json();
@@ -25,27 +22,27 @@ async function main() {
 }
 function parseCiEnv(ciEnv) {
     const githubAppAppId = (() => {
-        const v = ciEnv["GITHUB_APP_APP_ID"];
+        const v = ciEnv["_GITHUB_APP_APP_ID"];
         if (!v) {
-            throw new Error("Missing GITHUB_APP_APP_ID from .env.ci");
+            throw new Error("Missing _GITHUB_APP_APP_ID from env");
         }
         return v;
     })();
     const githubAppInstallationId = (() => {
-        const v = ciEnv["GITHUB_APP_INSTALLATION_ID"];
+        const v = ciEnv["_GITHUB_APP_INSTALLATION_ID"];
         if (!v) {
-            throw new Error("Missing GITHUB_APP_INSTALLATION_ID from .env.ci");
+            throw new Error("Missing _GITHUB_APP_INSTALLATION_ID from env");
         }
         return v;
     })();
-    const githubAppPrivateKeyB64 = (() => {
-        const v = ciEnv["GITHUB_APP_PRIVATE_KEY_B64"];
+    const githubAppPrivateKey = (() => {
+        const v = ciEnv["_GITHUB_APP_PEM_CONTENT"];
         if (!v) {
-            throw new Error("Missing GITHUB_APP_PRIVATE_KEY_B64 from .env.ci");
+            throw new Error("Missing _GITHUB_APP_PEM_CONTENT from env");
         }
         return v;
     })();
-    return { githubAppAppId, githubAppInstallationId, githubAppPrivateKeyB64 };
+    return { githubAppAppId, githubAppInstallationId, githubAppPrivateKey };
 }
 main()
     .then(() => {

package/dist/internal/upload-npm/beta/index.js

@@ -1,6 +1,5 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { EnvClient, EnvClientStrategy } from "../../../env";
 import { GitHubClient } from "../../../gh";
 import { NPMClient } from "../../../npm";
 import { Utils } from "../../../utils";
@@ -18,12 +17,11 @@ const { sha, prId } = await yargs(hideBin(process.argv))
     .strict()
     .parse();
 async function main() {
-    const envClient = EnvClient.create(EnvClientStrategy.GIT_CRYPT);
-    const { githubAppAppId, githubAppInstallationId, githubAppPrivateKeyB64 } = parseCiEnv(await envClient.readFromEnv(".env.ci"));
+    const { githubAppAppId, githubAppInstallationId, githubAppPrivateKey } = parseCiEnv(process.env);
     const ghClient = await GitHubClient.createWithGithubAppToken({
         appId: githubAppAppId,
         installationId: githubAppInstallationId,
-        privateKey: await Utils.decodeBase64EncodedString(githubAppPrivateKeyB64),
+        privateKey: githubAppPrivateKey,
     });
     const npmClient = await NPMClient.create();
     const versioningClient = new VersioningClient(ghClient, VersionUpdatingStrategy.JSTS);
@@ -55,27 +53,27 @@ async function getShortSha(sha) {
 }
 function parseCiEnv(ciEnv) {
     const githubAppAppId = (() => {
-        const v = ciEnv["GITHUB_APP_APP_ID"];
+        const v = ciEnv["_GITHUB_APP_APP_ID"];
         if (!v) {
-            throw new Error("Missing GITHUB_APP_APP_ID from .env.ci");
+            throw new Error("Missing _GITHUB_APP_APP_ID from env");
         }
         return v;
     })();
     const githubAppInstallationId = (() => {
-        const v = ciEnv["GITHUB_APP_INSTALLATION_ID"];
+        const v = ciEnv["_GITHUB_APP_INSTALLATION_ID"];
         if (!v) {
-            throw new Error("Missing GITHUB_APP_INSTALLATION_ID from .env.ci");
+            throw new Error("Missing _GITHUB_APP_INSTALLATION_ID from env");
         }
         return v;
     })();
-    const githubAppPrivateKeyB64 = (() => {
-        const v = ciEnv["GITHUB_APP_PRIVATE_KEY_B64"];
+    const githubAppPrivateKey = (() => {
+        const v = ciEnv["_GITHUB_APP_PEM_CONTENT"];
         if (!v) {
-            throw new Error("Missing GITHUB_APP_PRIVATE_KEY_B64 from .env.ci");
+            throw new Error("Missing _GITHUB_APP_PEM_CONTENT from env");
         }
         return v;
     })();
-    return { githubAppAppId, githubAppInstallationId, githubAppPrivateKeyB64 };
+    return { githubAppAppId, githubAppInstallationId, githubAppPrivateKey };
 }
 main()
     .then(() => {

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

@@ -0,0 +1,22 @@
+import type { IProtobufCompilerBackendStrategy, ProtobufCompilerBackendPublishArgs } from "./types";
+import { type ProtobufArtifactKeeperBackend } from "../types";
+export declare class ArtifactKeeperProtobufCompilerBackend implements IProtobufCompilerBackendStrategy {
+    private readonly config;
+    constructor(config: ProtobufArtifactKeeperBackend);
+    publish({ generatedDirectory, targetLanguage, options, }: ProtobufCompilerBackendPublishArgs): Promise<void>;
+    private publishJava;
+    private publishMaven;
+    private publishGradle;
+    private publishRust;
+    private moveJavaSources;
+    private findRustFiles;
+    private createMavenPom;
+    private createMavenSettings;
+    private createGradleBuild;
+    private createCargoToml;
+    private createRustLibrary;
+    private escapeXml;
+    private get artifactKeeperUrl();
+    private get mavenRepositoryUrl();
+    private get cargoIndexUrl();
+}

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

@@ -0,0 +1,233 @@
+import { $ } from "bun";
+import { mkdir, mkdtemp, readdir, rename, rm, writeFile, } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { ProtobufTargetLanguage, } from "../types";
+const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
+const DEFAULT_PROST_VERSION = "0.14";
+export class ArtifactKeeperProtobufCompilerBackend {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async publish({ generatedDirectory, targetLanguage, options, }) {
+        switch (targetLanguage) {
+            case ProtobufTargetLanguage.JAVA:
+                await this.publishJava({
+                    generatedDirectory,
+                    options: options,
+                });
+                return;
+            case ProtobufTargetLanguage.RUST:
+                await this.publishRust({
+                    generatedDirectory,
+                    options: options,
+                });
+                return;
+            case ProtobufTargetLanguage.GO:
+                throw new Error("Artifact Keeper Go module publishing requires its upload workflow; only Go module consumption has been configured.");
+        }
+    }
+    async publishJava({ generatedDirectory, options, }) {
+        await this.moveJavaSources(generatedDirectory);
+        if (options.buildTool === "gradle") {
+            await this.publishGradle({ generatedDirectory, options });
+            return;
+        }
+        await this.publishMaven({ generatedDirectory, options });
+    }
+    async publishMaven({ generatedDirectory, options, }) {
+        await writeFile(path.join(generatedDirectory, "pom.xml"), this.createMavenPom(options));
+        const settingsDirectory = await mkdtemp(path.join(tmpdir(), "artifact-keeper-maven-"));
+        const settingsPath = path.join(settingsDirectory, "settings.xml");
+        await writeFile(settingsPath, this.createMavenSettings());
+        try {
+            await $ `mvn --settings ${settingsPath} deploy`.cwd(generatedDirectory);
+        }
+        finally {
+            await rm(settingsDirectory, { force: true, recursive: true });
+        }
+    }
+    async publishGradle({ generatedDirectory, options, }) {
+        await Promise.all([
+            writeFile(path.join(generatedDirectory, "build.gradle"), this.createGradleBuild(options)),
+            writeFile(path.join(generatedDirectory, "settings.gradle"), `rootProject.name = "${options.artifactId}"\n`),
+        ]);
+        await $ `gradle -PmavenUsername=${this.config.username} -PmavenPassword=${this.config.token} publish`.cwd(generatedDirectory);
+    }
+    async publishRust({ generatedDirectory, options, }) {
+        const generatedFiles = await this.findRustFiles(generatedDirectory);
+        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)),
+        ]);
+        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");
+        await mkdir(sourceDirectory, { recursive: true });
+        for (const entry of await readdir(generatedDirectory, {
+            withFileTypes: true,
+        })) {
+            if (entry.name === "src" ||
+                entry.name === "pom.xml" ||
+                entry.name === "build.gradle" ||
+                entry.name === "settings.gradle") {
+                continue;
+            }
+            await rename(path.join(generatedDirectory, entry.name), path.join(sourceDirectory, entry.name));
+        }
+    }
+    async findRustFiles(directory, baseDirectory = directory) {
+        const files = [];
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const filePath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (entry.name === "src")
+                    continue;
+                files.push(...(await this.findRustFiles(filePath, baseDirectory)));
+                continue;
+            }
+            if (entry.isFile() && entry.name.endsWith(".rs")) {
+                files.push(path.relative(baseDirectory, filePath).split(path.sep).join("/"));
+            }
+        }
+        return files;
+    }
+    createMavenPom(options) {
+        const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>${this.escapeXml(options.groupId)}</groupId>
+  <artifactId>${this.escapeXml(options.artifactId)}</artifactId>
+  <version>${this.escapeXml(options.version)}</version>
+  <properties>
+    <maven.compiler.release>17</maven.compiler.release>
+  </properties>
+  <dependencies>
+    <dependency>
+      <groupId>com.google.protobuf</groupId>
+      <artifactId>protobuf-java</artifactId>
+      <version>${this.escapeXml(protobufVersion)}</version>
+    </dependency>
+  </dependencies>
+  <distributionManagement>
+    <repository>
+      <id>maven</id>
+      <url>${this.escapeXml(this.mavenRepositoryUrl)}</url>
+    </repository>
+  </distributionManagement>
+</project>
+`;
+    }
+    createMavenSettings() {
+        return `<settings>
+  <servers>
+    <server>
+      <id>maven</id>
+      <username>${this.escapeXml(this.config.username)}</username>
+      <password>${this.escapeXml(this.config.token)}</password>
+    </server>
+  </servers>
+</settings>
+`;
+    }
+    createGradleBuild(options) {
+        const protobufVersion = options.protobufJavaVersion ?? DEFAULT_PROTOBUF_JAVA_VERSION;
+        return `plugins {
+    id "java"
+    id "maven-publish"
+}
+
+group = "${options.groupId}"
+version = "${options.version}"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation "com.google.protobuf:protobuf-java:${protobufVersion}"
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+publishing {
+    publications {
+        mavenJava(MavenPublication) {
+            from components.java
+            artifactId = "${options.artifactId}"
+        }
+    }
+    repositories {
+        maven {
+            url = uri("${this.mavenRepositoryUrl}")
+            credentials {
+                username = project.findProperty("mavenUsername")
+                password = project.findProperty("mavenPassword")
+            }
+        }
+    }
+}
+`;
+    }
+    createCargoToml(options) {
+        const prostVersion = options.prostVersion ?? DEFAULT_PROST_VERSION;
+        return `[package]
+name = "${options.crateName}"
+version = "${options.version}"
+edition = "2021"
+
+[dependencies]
+prost = "${prostVersion}"
+`;
+    }
+    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) {
+                case "<":
+                    return "&lt;";
+                case ">":
+                    return "&gt;";
+                case "&":
+                    return "&amp;";
+                case "'":
+                    return "&apos;";
+                case '"':
+                    return "&quot;";
+                default:
+                    return character;
+            }
+        });
+    }
+    get artifactKeeperUrl() {
+        return this.config.url.replace(/\/$/, "");
+    }
+    get mavenRepositoryUrl() {
+        return `${this.artifactKeeperUrl}/maven/maven/`;
+    }
+    get cargoIndexUrl() {
+        return `${this.artifactKeeperUrl}/cargo/cargo/index`;
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { IProtobufCompilerBackendStrategy } from "./types";
+import { type ProtobufCompilerBackendConfig } from "../types";
+export * from "./artifact-keeper";
+export * from "./types";
+export declare function createProtobufCompilerBackendStrategy(backend: ProtobufCompilerBackendConfig): IProtobufCompilerBackendStrategy;

package/dist/protobuf/backend/index.js

@@ -0,0 +1,10 @@
+import { ProtobufCompilerBackend, } from "../types";
+import { ArtifactKeeperProtobufCompilerBackend } from "./artifact-keeper";
+export * from "./artifact-keeper";
+export * from "./types";
+const BACKEND_STRATEGY_FACTORIES = {
+    [ProtobufCompilerBackend.ARTIFACT_KEEPER]: (backend) => new ArtifactKeeperProtobufCompilerBackend(backend),
+};
+export function createProtobufCompilerBackendStrategy(backend) {
+    return BACKEND_STRATEGY_FACTORIES[backend.type](backend);
+}

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

@@ -0,0 +1,9 @@
+import type { ProtobufTargetLanguage, ProtobufTargetLanguageOptions } from "../types";
+export interface ProtobufCompilerBackendPublishArgs {
+    generatedDirectory: string;
+    targetLanguage: ProtobufTargetLanguage;
+    options: ProtobufTargetLanguageOptions;
+}
+export interface IProtobufCompilerBackendStrategy {
+    publish(args: ProtobufCompilerBackendPublishArgs): Promise<void>;
+}

package/dist/protobuf/client.d.ts

@@ -0,0 +1,10 @@
+import { type ProtobufCompilerCompileArgs, type ProtobufCompilerCompileResult } from "./types";
+export declare class ProtobufCompilerClient {
+    compile({ backend, bufToken, targetLanguages, protoFilesLocation, outputDirectory, }: ProtobufCompilerCompileArgs): Promise<ProtobufCompilerCompileResult>;
+    installToolchains(): Promise<void>;
+    private generateWithBuf;
+    private getCompilationTargets;
+    private getConfiguredTargetLanguages;
+    private getBufGenerateInput;
+    private findBufModuleDirectory;
+}

package/dist/protobuf/client.js

@@ -0,0 +1,115 @@
+import { $ } from "bun";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import yaml from "yaml";
+import { isCmdAvailable } from "../utils/cmd";
+import { createProtobufCompilerBackendStrategy } from "./backend";
+import { GoProtobufTargetLanguageStrategy, JavaProtobufTargetLanguageStrategy, RustProtobufTargetLanguageStrategy, } from "./strategy";
+import { ProtobufTargetLanguage, } from "./types";
+const TARGET_LANGUAGE_STRATEGY_FACTORIES = {
+    [ProtobufTargetLanguage.JAVA]: () => new JavaProtobufTargetLanguageStrategy(),
+    [ProtobufTargetLanguage.GO]: () => new GoProtobufTargetLanguageStrategy(),
+    [ProtobufTargetLanguage.RUST]: () => new RustProtobufTargetLanguageStrategy(),
+};
+export class ProtobufCompilerClient {
+    async compile({ backend, bufToken, targetLanguages, protoFilesLocation, outputDirectory, }) {
+        await this.installToolchains();
+        const outputDirectoryPath = path.resolve(outputDirectory ??
+            (await mkdtemp(path.join(tmpdir(), "protobuf-compiler-"))));
+        const targets = this.getCompilationTargets(targetLanguages);
+        const compilerBackend = backend ? createProtobufCompilerBackendStrategy(backend) : undefined;
+        await mkdir(outputDirectoryPath, { recursive: true });
+        await this.generateWithBuf({
+            bufToken,
+            outputDirectory: outputDirectoryPath,
+            protoFilesLocation,
+            targetStrategies: targets.map(({ strategy }) => strategy),
+        });
+        const generatedDirectories = {};
+        for (const { language, strategy } of targets) {
+            generatedDirectories[language] = path.join(outputDirectoryPath, strategy.outputDirectoryName);
+        }
+        if (compilerBackend) {
+            for (const { language, options } of targets) {
+                const generatedDirectory = generatedDirectories[language];
+                if (!generatedDirectory) {
+                    throw new Error("Generated code directory was not created.");
+                }
+                await compilerBackend.publish({
+                    generatedDirectory,
+                    options,
+                    targetLanguage: language,
+                });
+            }
+        }
+        return { generatedDirectories, outputDirectory: outputDirectoryPath };
+    }
+    async installToolchains() {
+        if (!(await isCmdAvailable("buf"))) {
+            console.log("Buf is missing, installing globally via NPM...");
+            await $ `npm i -g @bufbuild/buf`;
+        }
+    }
+    async generateWithBuf({ bufToken, protoFilesLocation, outputDirectory, targetStrategies, }) {
+        const templateDirectory = await mkdtemp(path.join(tmpdir(), "protobuf-buf-template-"));
+        const templatePath = path.join(templateDirectory, "buf.gen.yaml");
+        const { input, pathFilter } = await this.getBufGenerateInput(protoFilesLocation);
+        const pathFlag = pathFilter ? ["--path", pathFilter] : [];
+        await writeFile(templatePath, yaml.stringify({
+            version: "v2",
+            plugins: targetStrategies.map((strategy) => ({
+                out: strategy.outputDirectoryName,
+                remote: strategy.remotePlugin,
+            })),
+        }));
+        try {
+            const command = bufToken ?
+                $.env({
+                    ...process.env,
+                    BUF_TOKEN: bufToken,
+                }) `buf generate ${input} --template ${templatePath} ${pathFlag}`.cwd(outputDirectory)
+                : $ `buf generate ${input} --template ${templatePath} ${pathFlag}`.cwd(outputDirectory);
+            await command;
+        }
+        finally {
+            await rm(templateDirectory, { force: true, recursive: true });
+        }
+    }
+    getCompilationTargets(targetLanguages) {
+        return this.getConfiguredTargetLanguages(targetLanguages).map(([language, options]) => ({
+            language,
+            options,
+            strategy: TARGET_LANGUAGE_STRATEGY_FACTORIES[language](),
+        }));
+    }
+    getConfiguredTargetLanguages(targetLanguages) {
+        return Object.entries(targetLanguages).flatMap(([language, options]) => options ? [[Number(language), options]] : []);
+    }
+    async getBufGenerateInput(protoFilesLocation) {
+        const resolvedLocation = path.resolve(protoFilesLocation);
+        const stats = await Bun.file(resolvedLocation).stat();
+        if (stats.isFile() && !resolvedLocation.endsWith(".proto")) {
+            throw new Error(`${protoFilesLocation} is not a .proto file.`);
+        }
+        const sourceDirectory = stats.isFile() ? path.dirname(resolvedLocation) : resolvedLocation;
+        const moduleDirectory = (await this.findBufModuleDirectory(sourceDirectory)) ?? sourceDirectory;
+        return {
+            input: moduleDirectory,
+            pathFilter: moduleDirectory === resolvedLocation ? undefined : resolvedLocation,
+        };
+    }
+    async findBufModuleDirectory(directory) {
+        let currentDirectory = path.resolve(directory);
+        while (true) {
+            if (await Bun.file(path.join(currentDirectory, "buf.yaml")).exists()) {
+                return currentDirectory;
+            }
+            const parentDirectory = path.dirname(currentDirectory);
+            if (parentDirectory === currentDirectory) {
+                return null;
+            }
+            currentDirectory = parentDirectory;
+        }
+    }
+}

package/dist/protobuf/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * from "./types";

package/dist/protobuf/index.js

@@ -0,0 +1,2 @@
+export * from "./client";
+export * from "./types";

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

@@ -0,0 +1,5 @@
+import type { IProtobufTargetLanguageStrategy } from "./types";
+export declare class GoProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
+    readonly outputDirectoryName = "go";
+    readonly remotePlugin = "buf.build/protocolbuffers/go";
+}

package/dist/protobuf/strategy/go.js

@@ -0,0 +1,4 @@
+export class GoProtobufTargetLanguageStrategy {
+    outputDirectoryName = "go";
+    remotePlugin = "buf.build/protocolbuffers/go";
+}

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

@@ -0,0 +1,4 @@
+export * from "./go";
+export * from "./java";
+export * from "./rust";
+export * from "./types";

package/dist/protobuf/strategy/index.js

@@ -0,0 +1,4 @@
+export * from "./go";
+export * from "./java";
+export * from "./rust";
+export * from "./types";

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

@@ -0,0 +1,5 @@
+import type { IProtobufTargetLanguageStrategy } from "./types";
+export declare class JavaProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
+    readonly outputDirectoryName = "java";
+    readonly remotePlugin = "buf.build/protocolbuffers/java";
+}

package/dist/protobuf/strategy/java.js

@@ -0,0 +1,4 @@
+export class JavaProtobufTargetLanguageStrategy {
+    outputDirectoryName = "java";
+    remotePlugin = "buf.build/protocolbuffers/java";
+}

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

@@ -0,0 +1,5 @@
+import type { IProtobufTargetLanguageStrategy } from "./types";
+export declare class RustProtobufTargetLanguageStrategy implements IProtobufTargetLanguageStrategy {
+    readonly outputDirectoryName = "rust";
+    readonly remotePlugin = "buf.build/community/neoeinstein-prost";
+}

package/dist/protobuf/strategy/rust.js

@@ -0,0 +1,4 @@
+export class RustProtobufTargetLanguageStrategy {
+    outputDirectoryName = "rust";
+    remotePlugin = "buf.build/community/neoeinstein-prost";
+}

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

@@ -0,0 +1,4 @@
+export interface IProtobufTargetLanguageStrategy {
+    readonly outputDirectoryName: string;
+    readonly remotePlugin: string;
+}

package/dist/protobuf/types.d.ts

@@ -0,0 +1,56 @@
+export declare enum ProtobufCompilerBackend {
+    ARTIFACT_KEEPER = 0
+}
+export declare enum ProtobufSourceLanguage {
+    RUST = 0
+}
+export declare enum ProtobufTargetLanguage {
+    JAVA = 0,
+    RUST = 1,
+    GO = 2
+}
+export interface ProtobufArtifactKeeperBackend {
+    type: ProtobufCompilerBackend.ARTIFACT_KEEPER;
+    url: string;
+    username: string;
+    token: string;
+}
+export type ProtobufCompilerBackendConfig = ProtobufArtifactKeeperBackend;
+export interface ProtobufJavaTargetLanguageOptions {
+    groupId: string;
+    artifactId: string;
+    version: string;
+    buildTool?: "maven" | "gradle";
+    protobufJavaVersion?: string;
+}
+export interface ProtobufRustTargetLanguageOptions {
+    crateName: string;
+    version: string;
+    prostVersion?: string;
+}
+export interface ProtobufGoTargetLanguageOptions {
+    modulePath: string;
+    version: string;
+}
+export type ProtobufTargetLanguageOptions = ProtobufGoTargetLanguageOptions | ProtobufJavaTargetLanguageOptions | ProtobufRustTargetLanguageOptions;
+export type ProtobufTargetLanguages = {
+    [ProtobufTargetLanguage.JAVA]?: ProtobufJavaTargetLanguageOptions;
+    [ProtobufTargetLanguage.RUST]?: ProtobufRustTargetLanguageOptions;
+    [ProtobufTargetLanguage.GO]?: ProtobufGoTargetLanguageOptions;
+};
+export interface ProtobufCompilerCompileArgs {
+    /** All targets are published through this one backend. */
+    backend?: ProtobufCompilerBackendConfig;
+    sourceLanguage: ProtobufSourceLanguage;
+    /** Optional BSR API token used for Buf remote plugins. */
+    bufToken?: string;
+    targetLanguages: ProtobufTargetLanguages;
+    /** Directory containing proto files, or one specific `.proto` file. */
+    protoFilesLocation: string;
+    /** Defaults to a temporary directory. */
+    outputDirectory?: string;
+}
+export interface ProtobufCompilerCompileResult {
+    outputDirectory: string;
+    generatedDirectories: Partial<Record<ProtobufTargetLanguage, string>>;
+}

package/dist/protobuf/types.js

@@ -0,0 +1,14 @@
+export var ProtobufCompilerBackend;
+(function (ProtobufCompilerBackend) {
+    ProtobufCompilerBackend[ProtobufCompilerBackend["ARTIFACT_KEEPER"] = 0] = "ARTIFACT_KEEPER";
+})(ProtobufCompilerBackend || (ProtobufCompilerBackend = {}));
+export var ProtobufSourceLanguage;
+(function (ProtobufSourceLanguage) {
+    ProtobufSourceLanguage[ProtobufSourceLanguage["RUST"] = 0] = "RUST";
+})(ProtobufSourceLanguage || (ProtobufSourceLanguage = {}));
+export var ProtobufTargetLanguage;
+(function (ProtobufTargetLanguage) {
+    ProtobufTargetLanguage[ProtobufTargetLanguage["JAVA"] = 0] = "JAVA";
+    ProtobufTargetLanguage[ProtobufTargetLanguage["RUST"] = 1] = "RUST";
+    ProtobufTargetLanguage[ProtobufTargetLanguage["GO"] = 2] = "GO";
+})(ProtobufTargetLanguage || (ProtobufTargetLanguage = {}));

package/dist/utils/cmd.js

@@ -3,7 +3,7 @@ import { fromPromise } from "neverthrow";
 const GENERIC_ERROR = 1;
 const SUCCESS = 0;
 export async function isCmdAvailable(cmd) {
-    return ((await fromPromise($ `which -v ${cmd}`.quiet(), (e) => e)
+    return ((await fromPromise($ `which ${cmd}`.quiet(), (e) => e)
         .map((s) => s.exitCode)
         .unwrapOr(GENERIC_ERROR)) === SUCCESS);
 }

package/dist/versioning/client.js

@@ -3,6 +3,7 @@ import { VersionUpdatingStrategy, } from "./types";
 import { JavaMavenVersioningClient } from "./updating/java/maven";
 import { JavascriptPackageJsonVersioningClient } from "./updating/jsts";
 import { NoneVersioningClient } from "./updating/none";
+import { RustCargoVersioningClient } from "./updating/rust/cargo";
 export class VersioningClient {
     githubClient;
     static INITIAL_VERSION = "1.0.0";
@@ -17,6 +18,8 @@ export class VersioningClient {
                 return new JavascriptPackageJsonVersioningClient();
             case VersionUpdatingStrategy.JAVA_MAVEN:
                 return new JavaMavenVersioningClient();
+            case VersionUpdatingStrategy.RUST_CARGO:
+                return new RustCargoVersioningClient();
             case VersionUpdatingStrategy.NONE:
                 return new NoneVersioningClient();
         }

package/dist/versioning/types.d.ts

@@ -1,7 +1,8 @@
 export declare enum VersionUpdatingStrategy {
     JSTS = 0,
     JAVA_MAVEN = 1,
-    NONE = 2
+    RUST_CARGO = 2,
+    NONE = 3
 }
 export interface IVersionUpdatingClient {
     update(version: string): Promise<void>;
@@ -37,3 +38,5 @@ export interface IJavascriptPackageJsonVersionUpdatingClient extends IVersionUpd
 }
 export interface IJavaMavenVersionUpdatingClient extends IVersionUpdatingClient {
 }
+export interface IRustCargoVersionUpdatingClient extends IVersionUpdatingClient {
+}

package/dist/versioning/types.js

@@ -2,5 +2,6 @@ export var VersionUpdatingStrategy;
 (function (VersionUpdatingStrategy) {
     VersionUpdatingStrategy[VersionUpdatingStrategy["JSTS"] = 0] = "JSTS";
     VersionUpdatingStrategy[VersionUpdatingStrategy["JAVA_MAVEN"] = 1] = "JAVA_MAVEN";
-    VersionUpdatingStrategy[VersionUpdatingStrategy["NONE"] = 2] = "NONE";
+    VersionUpdatingStrategy[VersionUpdatingStrategy["RUST_CARGO"] = 2] = "RUST_CARGO";
+    VersionUpdatingStrategy[VersionUpdatingStrategy["NONE"] = 3] = "NONE";
 })(VersionUpdatingStrategy || (VersionUpdatingStrategy = {}));

package/dist/versioning/updating/rust/cargo/index.d.ts

@@ -0,0 +1,6 @@
+import type { IRustCargoVersionUpdatingClient } from "../../../types";
+import { BaseVersionUpdatingClient } from "../../base";
+export declare class RustCargoVersioningClient extends BaseVersionUpdatingClient implements IRustCargoVersionUpdatingClient {
+    update(version: string): Promise<void>;
+    private updatePackageVersionInCargoToml;
+}

package/dist/versioning/updating/rust/cargo/index.js

@@ -0,0 +1,50 @@
+import { BaseVersionUpdatingClient } from "../../base";
+export class RustCargoVersioningClient extends BaseVersionUpdatingClient {
+    async update(version) {
+        const files = await this.findFiles("**/Cargo.toml");
+        for (const fileLocation of files) {
+            const file = Bun.file(fileLocation);
+            const oldCargoToml = await file.text();
+            const newCargoToml = this.updatePackageVersionInCargoToml(oldCargoToml, version);
+            if (!newCargoToml) {
+                continue;
+            }
+            await Bun.write(fileLocation, newCargoToml);
+            this.logFileLocationUpdated(fileLocation, version);
+        }
+    }
+    updatePackageVersionInCargoToml(cargoToml, version) {
+        const lines = cargoToml.split("\n");
+        let insidePackageSection = false;
+        let packageSectionFound = false;
+        let packageVersionLineIndex = -1;
+        for (let index = 0; index < lines.length; index++) {
+            const line = lines[index];
+            if (!line)
+                continue;
+            const sectionMatch = line.match(/^\s*\[(.+)\]\s*$/);
+            if (sectionMatch) {
+                const sectionName = sectionMatch[1]?.trim();
+                insidePackageSection = sectionName === "package";
+                if (insidePackageSection) {
+                    packageSectionFound = true;
+                }
+                continue;
+            }
+            if (!insidePackageSection)
+                continue;
+            if (/^\s*version(?:\.[A-Za-z0-9_-]+)?\s*=/.test(line)) {
+                packageVersionLineIndex = index;
+                break;
+            }
+        }
+        if (!packageSectionFound) {
+            return null;
+        }
+        if (packageVersionLineIndex === -1) {
+            throw new Error("Can't find version key inside of package section in Cargo.toml");
+        }
+        lines[packageVersionLineIndex] = `version = "${version}"`;
+        return `${lines.join("\n").replace(/\n*$/, "\n")}`;
+    }
+}

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.76",
+  "version": "1.0.77",
   "repository": {
     "url": "git+https://github.com/tahminator/pipeline.git"
   },
@@ -21,14 +21,13 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "test": "bun run typecheck && bun run fmt && bun run lint",
+    "test": "bun run typecheck && bun run fmt && bun run lint && bun test",
     "fmt": "bun run prettier",
     "lint": "bun run eslint",
     "eslint": "eslint .",
     "eslint:fix": "eslint . --fix",
     "prettier": "prettier --check .",
     "prettier:fix": "prettier --write .",
-    "vt": "vitest run",
     "build": "tsc -p tsconfig.build.json"
   },
   "devDependencies": {