@tahminator/pipeline 1.0.76-beta.4076a21f → 1.0.76-beta.6560b5dd

package/README.md

@@ -38,10 +38,7 @@ import {
   EnvClient,
   GitHubClient,
   NPMClient,
-  ProtobufCompilerBackend,
   ProtobufCompilerClient,
-  ProtobufSourceLanguage,
-  ProtobufTargetLanguage,
   PulumiClient,
   SonarScannerClient,
   Utils,
@@ -185,25 +182,24 @@ 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.
+Generate protobuf clients with the [Buf CLI](https://buf.build/docs/installation/) and its remote plugins, then optionally upload them to a GitHub repository path. The client installs Buf globally with npm when necessary.
 
 ```ts
-const protobuf = new ProtobufCompilerClient();
+const gh = await GitHubClient.createWithGithubAppToken({
+  appId: process.env.GH_APP_ID!,
+  privateKey: await Utils.decodeBase64EncodedString(
+    process.env.GH_PRIVATE_KEY_B64!,
+  ),
+  installationId: process.env.GH_INSTALLATION_ID!,
+});
+const protobuf = new ProtobufCompilerClient(gh);
 
 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",
+      uploadLocation: "Patina-Network/proto-clients/java",
     },
   },
   protoFilesLocation: "./proto",
@@ -392,7 +388,6 @@ 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/protobuf/client.d.ts

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

package/dist/protobuf/client.js

@@ -4,21 +4,18 @@ 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, }) {
+    githubClient;
+    constructor(githubClient) {
+        this.githubClient = githubClient;
+    }
+    async compile({ 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,
@@ -30,18 +27,17 @@ export class ProtobufCompilerClient {
         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,
-                });
+        for (const { language, options } of targets) {
+            if (!options.uploadLocation)
+                continue;
+            const generatedDirectory = generatedDirectories[language];
+            if (!generatedDirectory) {
+                throw new Error("Generated code directory was not created.");
             }
+            await this.uploadGeneratedDirectory({
+                generatedDirectory,
+                options,
+            });
         }
         return { generatedDirectories, outputDirectory: outputDirectoryPath };
     }
@@ -80,11 +76,27 @@ export class ProtobufCompilerClient {
         return this.getConfiguredTargetLanguages(targetLanguages).map(([language, options]) => ({
             language,
             options,
-            strategy: TARGET_LANGUAGE_STRATEGY_FACTORIES[language](),
+            strategy: this.getTargetLanguageStrategy(language),
         }));
     }
     getConfiguredTargetLanguages(targetLanguages) {
-        return Object.entries(targetLanguages).flatMap(([language, options]) => options ? [[Number(language), options]] : []);
+        const targets = [];
+        for (const [language, options] of Object.entries(targetLanguages)) {
+            if (!options)
+                continue;
+            targets.push([Number(language), options]);
+        }
+        return targets;
+    }
+    getTargetLanguageStrategy(targetLanguage) {
+        switch (targetLanguage) {
+            case ProtobufTargetLanguage.JAVA:
+                return new JavaProtobufTargetLanguageStrategy();
+            case ProtobufTargetLanguage.GO:
+                return new GoProtobufTargetLanguageStrategy();
+            case ProtobufTargetLanguage.RUST:
+                return new RustProtobufTargetLanguageStrategy();
+        }
     }
     async getBufGenerateInput(protoFilesLocation) {
         const resolvedLocation = path.resolve(protoFilesLocation);
@@ -112,4 +124,31 @@ export class ProtobufCompilerClient {
             currentDirectory = parentDirectory;
         }
     }
+    async uploadGeneratedDirectory({ generatedDirectory, options, }) {
+        if (!options.uploadLocation) {
+            throw new Error("An upload location is required to upload generated code.");
+        }
+        const repository = this.parseGitHubRepository(options.uploadLocation, options.directory);
+        await this.githubClient.DANGEROUS__uploadDirectoryContents({
+            owner: repository.owner,
+            repository: repository.repository,
+            directory: repository.directory,
+            sourceDirectory: generatedDirectory,
+            message: options.commitMessage ?? "chore: update generated protobuf clients",
+            branch: options.branch,
+        });
+    }
+    parseGitHubRepository(uploadLocation, directory) {
+        const [owner, repository, ...pathParts] = uploadLocation
+            .split("/")
+            .filter(Boolean);
+        if (!owner || !repository) {
+            throw new Error("GitHub upload location must be in the form `owner/repo` or `owner/repo/path`.");
+        }
+        return {
+            directory: directory ?? pathParts.join("/"),
+            owner,
+            repository,
+        };
+    }
 }

package/dist/protobuf/types.d.ts

@@ -1,6 +1,3 @@
-export declare enum ProtobufCompilerBackend {
-    ARTIFACT_KEEPER = 0
-}
 export declare enum ProtobufSourceLanguage {
     RUST = 0
 }
@@ -9,41 +6,35 @@ export declare enum ProtobufTargetLanguage {
     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 ProtobufTargetLanguageOptions {
+    /**
+     * Either `owner/repo` or `owner/repo/path/inside/repo`.
+     *
+     * @example "Patina-Network/proto-clients/java"
+     */
+    uploadLocation?: string;
+    /** Overrides the path parsed from `uploadLocation`. */
+    directory?: string;
+    branch?: string;
+    commitMessage?: string;
+}
+export type ProtobufTargetLanguages = Partial<Record<ProtobufTargetLanguage, ProtobufTargetLanguageOptions>>;
 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;
+    /**
+     * A map of target language to target-specific options.
+     *
+     * @example
+     * ```ts
+     * {
+     *   [ProtobufTargetLanguage.JAVA]: {
+     *     uploadLocation: "Patina-Network/proto-clients/java",
+     *   },
+     * }
+     * ```
+     */
     targetLanguages: ProtobufTargetLanguages;
     /** Directory containing proto files, or one specific `.proto` file. */
     protoFilesLocation: string;

package/dist/protobuf/types.js

@@ -1,7 +1,3 @@
-export var ProtobufCompilerBackend;
-(function (ProtobufCompilerBackend) {
-    ProtobufCompilerBackend[ProtobufCompilerBackend["ARTIFACT_KEEPER"] = 0] = "ARTIFACT_KEEPER";
-})(ProtobufCompilerBackend || (ProtobufCompilerBackend = {}));
 export var ProtobufSourceLanguage;
 (function (ProtobufSourceLanguage) {
     ProtobufSourceLanguage[ProtobufSourceLanguage["RUST"] = 0] = "RUST";

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 ${cmd}`.quiet(), (e) => e)
+    return ((await fromPromise($ `which -v ${cmd}`.quiet(), (e) => e)
         .map((s) => s.exitCode)
         .unwrapOr(GENERIC_ERROR)) === SUCCESS);
 }

package/dist/versioning/client.js

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

package/dist/versioning/types.js

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

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-beta.4076a21f",
+  "version": "1.0.76-beta.6560b5dd",
   "repository": {
     "url": "git+https://github.com/tahminator/pipeline.git"
   },

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

@@ -1,22 +0,0 @@
-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

@@ -1,233 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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/versioning/updating/rust/cargo/index.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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")}`;
-    }
-}