@tahminator/pipeline 1.0.76-beta.0f9c2cb9 → 1.0.76-beta.4076a21f

package/README.md

@@ -194,6 +194,7 @@ 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,
@@ -391,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/protobuf/backend/artifact-keeper.d.ts

@@ -1,12 +1,9 @@
-import { type ProtobufArtifactKeeperBackend, type ProtobufTargetLanguageOptions, ProtobufTargetLanguage } from "../types";
-export declare class ArtifactKeeperProtobufCompilerBackend {
+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, }: {
-        generatedDirectory: string;
-        targetLanguage: ProtobufTargetLanguage;
-        options: ProtobufTargetLanguageOptions;
-    }): Promise<void>;
+    publish({ generatedDirectory, targetLanguage, options, }: ProtobufCompilerBackendPublishArgs): Promise<void>;
     private publishJava;
     private publishMaven;
     private publishGradle;

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

@@ -3,7 +3,6 @@ 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";
-const DEFAULT_ARTIFACT_KEEPER_URL = "https://pkg.vpn.patinanetwork.org";
 const DEFAULT_PROTOBUF_JAVA_VERSION = "4.32.1";
 const DEFAULT_PROST_VERSION = "0.14";
 export class ArtifactKeeperProtobufCompilerBackend {
@@ -223,7 +222,7 @@ prost = "${prostVersion}"
         });
     }
     get artifactKeeperUrl() {
-        return (this.config.url ?? DEFAULT_ARTIFACT_KEEPER_URL).replace(/\/$/, "");
+        return this.config.url.replace(/\/$/, "");
     }
     get mavenRepositoryUrl() {
         return `${this.artifactKeeperUrl}/maven/maven/`;

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

@@ -1 +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

@@ -1 +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

@@ -5,7 +5,6 @@ export declare class ProtobufCompilerClient {
     private generateWithBuf;
     private getCompilationTargets;
     private getConfiguredTargetLanguages;
-    private getTargetLanguageStrategy;
     private getBufGenerateInput;
     private findBufModuleDirectory;
 }

package/dist/protobuf/client.js

@@ -4,16 +4,21 @@ import { tmpdir } from "node:os";
 import path from "node:path";
 import yaml from "yaml";
 import { isCmdAvailable } from "../utils/cmd";
-import { ArtifactKeeperProtobufCompilerBackend } from "./backend";
+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 artifactKeeper = backend ? new ArtifactKeeperProtobufCompilerBackend(backend) : undefined;
+        const compilerBackend = backend ? createProtobufCompilerBackendStrategy(backend) : undefined;
         await mkdir(outputDirectoryPath, { recursive: true });
         await this.generateWithBuf({
             bufToken,
@@ -25,13 +30,13 @@ export class ProtobufCompilerClient {
         for (const { language, strategy } of targets) {
             generatedDirectories[language] = path.join(outputDirectoryPath, strategy.outputDirectoryName);
         }
-        if (artifactKeeper) {
+        if (compilerBackend) {
             for (const { language, options } of targets) {
                 const generatedDirectory = generatedDirectories[language];
                 if (!generatedDirectory) {
                     throw new Error("Generated code directory was not created.");
                 }
-                await artifactKeeper.publish({
+                await compilerBackend.publish({
                     generatedDirectory,
                     options,
                     targetLanguage: language,
@@ -75,27 +80,11 @@ export class ProtobufCompilerClient {
         return this.getConfiguredTargetLanguages(targetLanguages).map(([language, options]) => ({
             language,
             options,
-            strategy: this.getTargetLanguageStrategy(language),
+            strategy: TARGET_LANGUAGE_STRATEGY_FACTORIES[language](),
         }));
     }
     getConfiguredTargetLanguages(targetLanguages) {
-        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();
-        }
+        return Object.entries(targetLanguages).flatMap(([language, options]) => options ? [[Number(language), options]] : []);
     }
     async getBufGenerateInput(protoFilesLocation) {
         const resolvedLocation = path.resolve(protoFilesLocation);

package/dist/protobuf/types.d.ts

@@ -11,11 +11,11 @@ export declare enum ProtobufTargetLanguage {
 }
 export interface ProtobufArtifactKeeperBackend {
     type: ProtobufCompilerBackend.ARTIFACT_KEEPER;
-    /** Defaults to `https://pkg.vpn.patinanetwork.org`. */
-    url?: string;
+    url: string;
     username: string;
     token: string;
 }
+export type ProtobufCompilerBackendConfig = ProtobufArtifactKeeperBackend;
 export interface ProtobufJavaTargetLanguageOptions {
     groupId: string;
     artifactId: string;
@@ -40,7 +40,7 @@ export type ProtobufTargetLanguages = {
 };
 export interface ProtobufCompilerCompileArgs {
     /** All targets are published through this one backend. */
-    backend?: ProtobufArtifactKeeperBackend;
+    backend?: ProtobufCompilerBackendConfig;
     sourceLanguage: ProtobufSourceLanguage;
     /** Optional BSR API token used for Buf remote plugins. */
     bufToken?: string;

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