@tahminator/pipeline 1.0.0

package/README.md

@@ -0,0 +1,21 @@
+<h1>
+  <a href="https://www.npmjs.com/package/@tahminator/pipeline">
+    <code>@tahminator/pipeline</code>
+  </a>
+</h1>
+
+A collection of Bun shell scripts that can be re-used in various CICD pipelines.
+
+## Setup
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+To run:
+
+```bash
+bun run src/index.ts
+```

package/dist/docker/index.d.ts

@@ -0,0 +1,15 @@
+export declare class DockerClient {
+    private readonly username;
+    private readonly pat;
+    private constructor();
+    static create(username: string, pat: string): Promise<DockerClient>;
+    /**
+     * Will lookup the Docker Hub image of `originalTag` & add `newGithubTags` to it.
+     */
+    promoteDockerImage({ originalTag, newGithubTags, repository, }: {
+        originalTag: string;
+        newGithubTags: string[];
+        repository: string;
+    }): Promise<void>;
+    cleanup(): Promise<void>;
+}

package/dist/docker/index.js

@@ -0,0 +1,32 @@
+import { $ } from "bun";
+export class DockerClient {
+    username;
+    pat;
+    constructor(username, pat) {
+        this.username = username;
+        this.pat = pat;
+    }
+    static async create(username, pat) {
+        const client = new DockerClient(username, pat);
+        await $ `echo ${pat} | docker login -u ${username} --password-stdin`;
+        return client;
+    }
+    /**
+     * Will lookup the Docker Hub image of `originalTag` & add `newGithubTags` to it.
+     */
+    async promoteDockerImage({ originalTag, newGithubTags, repository, }) {
+        const fullRepo = `${this.username}/${repository}`;
+        const oldImage = `${fullRepo}:${originalTag}`;
+        await $ `docker pull ${oldImage}`;
+        for (const tag of newGithubTags) {
+            const newImage = `${fullRepo}:${tag}`;
+            console.log(`Promoting to ${newImage}...`);
+            await $ `docker tag ${oldImage} ${newImage}`;
+            await $ `docker push ${newImage}`;
+        }
+        console.log(`Promoted ${originalTag} to: ${newGithubTags.join(", ")}`);
+    }
+    async cleanup() {
+        await $ `docker logout`;
+    }
+}

package/dist/gh/client.d.ts

@@ -0,0 +1,11 @@
+export declare class GitHubClient {
+    private readonly client;
+    private readonly isExplicitToken;
+    private readonly tagManager;
+    private readonly outputManager;
+    private readonly prManager;
+    constructor(ghToken?: string);
+    createTag(...args: Parameters<typeof this.tagManager.createTag>): Promise<void>;
+    outputToGithubOutput(...args: Parameters<typeof this.outputManager.outputToGithubOutput>): Promise<void>;
+    updateK8sTagWithPR(...args: Parameters<typeof this.prManager.updateK8sTagWithPR>): Promise<void>;
+}

package/dist/gh/client.js

@@ -0,0 +1,33 @@
+import { Octokit } from "@octokit/rest";
+import { GitHubOutputManager } from "./output";
+import { GitHubPRManager } from "./pr";
+import { GitHubTagManager } from "./tag";
+export class GitHubClient {
+    client;
+    isExplicitToken;
+    tagManager;
+    outputManager;
+    prManager;
+    constructor(ghToken) {
+        this.isExplicitToken = !!ghToken;
+        const token = ghToken ?? process.env.GH_TOKEN;
+        if (!token) {
+            throw new Error("No GitHub token has been provided & GH_TOKEN cannot be found in environment");
+        }
+        this.client = new Octokit({
+            auth: token,
+        });
+        this.tagManager = new GitHubTagManager(this.client, this.isExplicitToken);
+        this.outputManager = new GitHubOutputManager(this.client);
+        this.prManager = new GitHubPRManager(this.client);
+    }
+    createTag(...args) {
+        return this.tagManager.createTag(...args);
+    }
+    outputToGithubOutput(...args) {
+        return this.outputManager.outputToGithubOutput(...args);
+    }
+    updateK8sTagWithPR(...args) {
+        return this.prManager.updateK8sTagWithPR(...args);
+    }
+}

package/dist/gh/index.d.ts

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

package/dist/gh/index.js

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

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

@@ -0,0 +1,15 @@
+import type { Octokit } from "@octokit/rest";
+export declare class GitHubOutputManager {
+    private readonly client;
+    constructor(client: Octokit);
+    /**
+     * Write an output back to Github Actions in order to re-use / pass
+     * data between steps, jobs, etc.
+     *
+     * @see documentation for passing outputs between jobs [here](https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/pass-job-outputs)
+     */
+    outputToGithubOutput({ overrideGithubOutputFile, ctx, }: {
+        overrideGithubOutputFile?: string;
+        ctx: Record<string, unknown>;
+    }): Promise<void>;
+}

package/dist/gh/output/index.js

@@ -0,0 +1,31 @@
+export class GitHubOutputManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Write an output back to Github Actions in order to re-use / pass
+     * data between steps, jobs, etc.
+     *
+     * @see documentation for passing outputs between jobs [here](https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/pass-job-outputs)
+     */
+    async outputToGithubOutput({ overrideGithubOutputFile, ctx, }) {
+        const githubOutputEnv = (() => {
+            const v = process.env.GITHUB_OUTPUT;
+            return v;
+        })();
+        const githubOutput = overrideGithubOutputFile ?? githubOutputEnv;
+        if (!githubOutput) {
+            throw new Error("Failed to find GITHUB_OUTPUT from environment and no explicit github output file override defined");
+        }
+        console.log("Outputting GitHub output...");
+        const w = Bun.file(githubOutput).writer();
+        for (const [k, v] of Object.entries(ctx)) {
+            console.log(`Piping ${k}`);
+            await w.write(`${k}<<EOF\n${JSON.stringify(v)}\nEOF\n`);
+        }
+        await w.flush();
+        await w.end();
+        console.log("GitHub output complete");
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { Octokit } from "@octokit/rest";
+import type { Environment, OwnerString, RepoString } from "../../types";
+export declare class GitHubPRManager {
+    private readonly client;
+    constructor(client: Octokit);
+    /**
+     *
+     * update k8s manifest repo with new tag version.
+     *
+     * @note `kustomizationFile` must look like this:
+     *
+     * ```yaml
+     * apiVersion: kustomize.config.k8s.io/v1beta1
+     * kind: Kustomization
+     * resources:
+     *   - deployment.yaml
+     *   - secrets.yaml
+     *   - service.yaml
+     *   - monitor.yaml
+     * commonLabels:
+     *   app: instalock-web
+     *   environment: production
+     * # This part specifically
+     * images:
+     *   - name: tahminator/instalock-web
+     *     newTag: a70ee0e
+     * ```
+     */
+    updateK8sTagWithPR({ client, newTag, imageName, kustomizationFilePath, environment, originRepo, manifestRepo, }: {
+        client: Octokit;
+        newTag: string;
+        imageName: string;
+        kustomizationFilePath: string;
+        environment: Environment;
+        originRepo: [OwnerString, RepoString];
+        manifestRepo: [OwnerString, RepoString];
+    }): Promise<void>;
+}

package/dist/gh/pr/index.js

@@ -0,0 +1,101 @@
+import yaml from "yaml";
+import { Utils } from "../../utils";
+import { kustomizeSchema } from "./schema";
+export class GitHubPRManager {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     *
+     * update k8s manifest repo with new tag version.
+     *
+     * @note `kustomizationFile` must look like this:
+     *
+     * ```yaml
+     * apiVersion: kustomize.config.k8s.io/v1beta1
+     * kind: Kustomization
+     * resources:
+     *   - deployment.yaml
+     *   - secrets.yaml
+     *   - service.yaml
+     *   - monitor.yaml
+     * commonLabels:
+     *   app: instalock-web
+     *   environment: production
+     * # This part specifically
+     * images:
+     *   - name: tahminator/instalock-web
+     *     newTag: a70ee0e
+     * ```
+     */
+    async updateK8sTagWithPR({ client, newTag, imageName, kustomizationFilePath, environment, originRepo, manifestRepo, }) {
+        const [manifestOwner, manifestRepository] = manifestRepo;
+        const [originOwner, originRepository] = originRepo;
+        const newBranchName = `${imageName}-${newTag}-${Utils.generateShortId()}`;
+        const { data: repo } = await client.rest.repos.get({
+            owner: manifestOwner,
+            repo: manifestRepository,
+        });
+        const baseBranch = repo.default_branch;
+        const { data: ref } = await client.rest.git.getRef({
+            owner: manifestOwner,
+            repo: manifestRepository,
+            ref: `heads/${baseBranch}`,
+        });
+        await client.rest.git.createRef({
+            owner: manifestOwner,
+            repo: manifestRepository,
+            ref: `refs/heads/${newBranchName}`,
+            sha: ref.object.sha,
+        });
+        const { data: file } = await client.rest.repos.getContent({
+            owner: manifestOwner,
+            repo: manifestRepository,
+            path: kustomizationFilePath,
+            ref: newBranchName,
+        });
+        if (Array.isArray(file))
+            throw new Error("Unexpected file shape found");
+        if (!file)
+            throw new Error("Kustomization file not found");
+        if (file.type !== "file")
+            throw new Error("Unexpected file type found");
+        if (!file.content)
+            throw new Error("Kustomization file is empty");
+        const currentYaml = Buffer.from(file.content ?? "", "base64").toString();
+        const doc = yaml.parseDocument(currentYaml);
+        const yamlObj = kustomizeSchema.parse(doc.toJS());
+        const targetImage = yamlObj.images?.find((img) => img.name === imageName);
+        if (!targetImage) {
+            console.debug(yamlObj);
+            throw new Error("Target image could not be found.");
+        }
+        targetImage.newTag = newTag;
+        doc.set("images", yamlObj.images);
+        const updatedYaml = doc.toString();
+        await client.rest.repos.createOrUpdateFileContents({
+            owner: manifestOwner,
+            repo: manifestRepository,
+            path: kustomizationFilePath,
+            message: `deploy: update ${imageName} to ${newTag}`,
+            content: Buffer.from(updatedYaml).toString("base64"),
+            sha: file.sha,
+            branch: newBranchName,
+        });
+        const { data: pr } = await client.rest.pulls.create({
+            owner: manifestOwner,
+            repo: manifestRepository,
+            title: `Deploying ${newTag} for ${imageName} in ${environment}`,
+            head: newBranchName,
+            base: baseBranch,
+            body: `Automated image tag change to ${newTag} for ${imageName} in ${environment} triggered by [${originOwner}/${originRepository}](https://github.com/${originOwner}/${originRepository}).`,
+        });
+        await client.rest.pulls.merge({
+            owner: manifestOwner,
+            repo: manifestRepository,
+            pull_number: pr.number,
+            merge_method: "squash",
+        });
+    }
+}

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

@@ -0,0 +1,8 @@
+import z from "zod";
+export declare const kustomizeSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"Kustomization">;
+    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        newTag: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;

package/dist/gh/pr/schema.js

@@ -0,0 +1,29 @@
+import z from "zod";
+/*
+ * schema should match the values we need from the below snippet:
+ *
+ * ```yaml
+ * apiVersion: kustomize.config.k8s.io/v1beta1
+ * kind: Kustomization
+ * resources:
+ *   - deployment.yaml
+ *   - secrets.yaml
+ *   - service.yaml
+ *   - monitor.yaml
+ * commonLabels:
+ *   app: instalock-web
+ *   environment: production
+ * images:
+ *   - name: tahminator/instalock-web
+ *     newTag: a70ee0e
+ * ```
+ */
+export const kustomizeSchema = z.object({
+    kind: z.literal("Kustomization"),
+    images: z
+        .array(z.object({
+        name: z.string(),
+        newTag: z.string(),
+    }))
+        .optional(),
+});

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

@@ -0,0 +1,23 @@
+import { Octokit } from "@octokit/rest";
+import semver from "semver";
+import type { OwnerString, RepoString } from "../../types";
+export declare class GitHubTagManager {
+    private readonly client;
+    readonly isExplicitToken: boolean;
+    private static readonly BASE_VERSION;
+    constructor(client: Octokit, isExplicitToken: boolean);
+    /**
+     * Utilizes the GitHub API to create a new tag version in the given repository.
+     *
+     * @note You **must** pass in a GitHub token because the regular Github bot token
+     * cannot trigger actions (due to fear of recursion). You must either provide a GitHub App token or
+     * a GitHub PAT.
+     */
+    createTag({ repositoryOverride, releaseType, onPreTagCreate, }: {
+        repositoryOverride?: [OwnerString, RepoString];
+        releaseType?: semver.ReleaseType;
+        onPreTagCreate?: (tag: string) => Promise<void>;
+    }): Promise<void>;
+    private parseRepository;
+    private createBlob;
+}

package/dist/gh/tag/index.js

@@ -0,0 +1,118 @@
+import { Octokit } from "@octokit/rest";
+import { $ } from "bun";
+import semver from "semver";
+export class GitHubTagManager {
+    client;
+    isExplicitToken;
+    static BASE_VERSION = "1.0.0";
+    constructor(client, isExplicitToken) {
+        this.client = client;
+        this.isExplicitToken = isExplicitToken;
+        if (!isExplicitToken) {
+            throw new Error("You must pass in an explicit GitHub token for this operation. You may either use a PAT or a GitHub App Token");
+        }
+    }
+    /**
+     * Utilizes the GitHub API to create a new tag version in the given repository.
+     *
+     * @note You **must** pass in a GitHub token because the regular Github bot token
+     * cannot trigger actions (due to fear of recursion). You must either provide a GitHub App token or
+     * a GitHub PAT.
+     */
+    async createTag({ repositoryOverride, releaseType, onPreTagCreate, }) {
+        const repositoryEnv = (() => {
+            const v = process.env.GITHUB_REPOSITORY;
+            return v;
+        })();
+        const [owner, repo] = this.parseRepository(repositoryOverride, repositoryEnv)();
+        const { data: tags } = await this.client.rest.repos.listTags({
+            owner,
+            repo,
+        });
+        const lastTag = tags
+            .map((t) => t.name)
+            .filter((v) => semver.valid(v))
+            .sort(semver.rcompare)[0];
+        const nextTag = lastTag ?
+            semver.inc(lastTag, releaseType ?? "patch")
+            : GitHubTagManager.BASE_VERSION;
+        if (!nextTag) {
+            throw new Error("Could not increment version");
+        }
+        const { data: repository } = await this.client.rest.repos.get({
+            owner,
+            repo,
+        });
+        const { data: branch } = await this.client.rest.repos.getBranch({
+            owner,
+            repo,
+            branch: repository.default_branch,
+        });
+        if (onPreTagCreate) {
+            await onPreTagCreate?.(nextTag);
+        }
+        const { stdout } = await $ `git status --porcelain`.quiet();
+        const changedFiles = stdout
+            .toString()
+            .split("\n")
+            .map((line) => line.slice(3).trim())
+            .filter(Boolean);
+        const sha = await this.createBlob({
+            owner,
+            repo,
+            changedFiles,
+            baseSha: branch.commit.commit.tree.sha,
+        });
+        const { data: commit } = await this.client.rest.git.createCommit({
+            owner,
+            repo,
+            message: `${nextTag}`,
+            tree: sha,
+            parents: [branch.commit.sha],
+        });
+        await this.client.rest.git.createRef({
+            owner,
+            repo,
+            ref: `refs/tags/${nextTag}`,
+            sha: commit.sha,
+        });
+    }
+    parseRepository(repositoryOverride, repositoryEnv) {
+        return () => {
+            if (repositoryOverride) {
+                return [repositoryOverride[0], repositoryOverride[1]];
+            }
+            if (repositoryEnv) {
+                return repositoryEnv.split("/");
+            }
+            throw new Error("GITHUB_REPOSITORY not found in environment and no explicit github repository override defined");
+        };
+    }
+    async createBlob({ owner, repo, baseSha, changedFiles, }) {
+        if (!changedFiles.length) {
+            return baseSha;
+        }
+        const treeEntries = await Promise.all(changedFiles.map(async (filePath) => {
+            const content = await Bun.file(filePath).text();
+            const { data: blob } = await this.client.rest.git.createBlob({
+                owner,
+                repo,
+                content,
+                encoding: "utf-8",
+            });
+            return {
+                path: filePath,
+                mode: "100644",
+                type: "blob",
+                sha: blob.sha,
+            };
+        }));
+        const { data: newTree } = await this.client.rest.git.createTree({
+            owner,
+            repo,
+            base_tree: baseSha,
+            tree: treeEntries,
+        });
+        return newTree.sha;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./gh";
+export * from "./docker";
+export * from "./types";
+export * from "./utils";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./gh";
+export * from "./docker";
+export * from "./types";
+export * from "./utils";

package/dist/internal/create-tag/index.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,33 @@
+import { GitHubClient } from "../../gh";
+import { getEnvVariables } from "../../utils/env";
+async function main() {
+    const { githubPat } = parseCiEnv(await getEnvVariables(["ci"]));
+    const ghClient = new GitHubClient(githubPat);
+    await ghClient.createTag({
+        onPreTagCreate: async (tag) => {
+            const file = Bun.file("./package.json");
+            const pkg = await file.json();
+            pkg.version = tag;
+            await Bun.write("./package.json", JSON.stringify(pkg, null, 2) + "\n");
+            console.log(`Successfully updated version in package.json to ${tag}`);
+        },
+    });
+}
+function parseCiEnv(ciEnv) {
+    const githubPat = (() => {
+        const v = ciEnv["GITHUB_PAT"];
+        if (!v) {
+            throw new Error("Missing GITHUB_PAT from .env.ci");
+        }
+        return v;
+    })();
+    return { githubPat };
+}
+main()
+    .then(() => {
+    process.exit(0);
+})
+    .catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/internal/upload-npm/index.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,26 @@
+import { $ } from "bun";
+import { getEnvVariables } from "../../utils/env";
+async function main() {
+    const { npmToken } = parseCiEnv(await getEnvVariables(["ci"]));
+    await $ `npm config set //registry.npmjs.org/:_authToken=${npmToken}`;
+    await $ `npm publish --access public`;
+    console.log("Package has been successfully published");
+}
+function parseCiEnv(ciEnv) {
+    const npmToken = (() => {
+        const v = ciEnv["NPM_TOKEN"];
+        if (!v) {
+            throw new Error("Missing NPM_TOKEN from .env.ci");
+        }
+        return v;
+    })();
+    return { npmToken };
+}
+main()
+    .then(() => {
+    process.exit(0);
+})
+    .catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+export type Environment = "staging" | "production";
+export type OwnerString = string;
+export type RepoString = string;

package/dist/utils/env.d.ts

@@ -0,0 +1,20 @@
+type Opts = {
+    baseDir?: string;
+    mask_PLZ_DO_NOT_TURN_OFF_UNLESS_YOU_KNOW_WHAT_UR_DOING?: boolean;
+};
+/**
+ * Load environment variables from encrypted `.env.*` files. This method will call `git-crypt unlock` for you if necessary.
+ *
+ * @param environments - List of environment files to load.
+ *
+ * @param opts - Optional overrides
+ * @param opts.baseDir - Directory of environment variable. Defaults to the root directory / ""
+ * @param opts.mask_PLZ_DO_NOT_TURN_OFF_UNLESS_YOU_KNOW_WHAT_UR_DOING - Should variables be masked. Defaults to `true`. __NOTE: This will only work in a GitHub Action runner.__
+ *
+ * @returns a map of the loaded environments as a key and value inside of a map.
+ *
+ * @note _Please note that duplicate environment variables will be overwritten, so
+ * the order in which you define `environments` does matter._
+ */
+export declare function getEnvVariables(environments: string[], opts?: Opts): Promise<Record<string, string>>;
+export {};

package/dist/utils/env.js

@@ -0,0 +1,67 @@
+import { $ } from "bun";
+// TODO: replace with a more robust solution
+let isGitCryptUnlocked = false;
+/**
+ * Load environment variables from encrypted `.env.*` files. This method will call `git-crypt unlock` for you if necessary.
+ *
+ * @param environments - List of environment files to load.
+ *
+ * @param opts - Optional overrides
+ * @param opts.baseDir - Directory of environment variable. Defaults to the root directory / ""
+ * @param opts.mask_PLZ_DO_NOT_TURN_OFF_UNLESS_YOU_KNOW_WHAT_UR_DOING - Should variables be masked. Defaults to `true`. __NOTE: This will only work in a GitHub Action runner.__
+ *
+ * @returns a map of the loaded environments as a key and value inside of a map.
+ *
+ * @note _Please note that duplicate environment variables will be overwritten, so
+ * the order in which you define `environments` does matter._
+ */
+export async function getEnvVariables(environments, opts) {
+    const { baseDir = "", mask_PLZ_DO_NOT_TURN_OFF_UNLESS_YOU_KNOW_WHAT_UR_DOING = true, } = opts ?? {};
+    if (!isGitCryptUnlocked) {
+        await $ `git-crypt unlock`.nothrow();
+        isGitCryptUnlocked = true;
+    }
+    const loaded = new Map();
+    for (const env of environments) {
+        const path = baseDir ? `${baseDir}/.env.${env}` : `.env.${env}`;
+        const envFile = Bun.file(path);
+        if (await envFile.exists()) {
+            console.log(`Loading ${envFile.name}`);
+            const content = await envFile.text();
+            const lines = content.split("\n").filter((s) => s.length > 0);
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith("#"))
+                    continue;
+                const match = (() => {
+                    const [key, ...rest] = trimmed.split("=");
+                    return [key, rest.join("=")];
+                })();
+                if (match.length === 2) {
+                    const [key, value] = match;
+                    const cleanKey = key.trim();
+                    let cleanValue = value.trim();
+                    if ((cleanValue.startsWith('"') && cleanValue.endsWith('"')) ||
+                        (cleanValue.startsWith("'") && cleanValue.endsWith("'"))) {
+                        cleanValue = cleanValue.slice(1, -1);
+                    }
+                    loaded.set(cleanKey, cleanValue);
+                }
+            }
+        }
+        else {
+            console.warn(`Warning: ${envFile.name} not found`);
+        }
+    }
+    if (mask_PLZ_DO_NOT_TURN_OFF_UNLESS_YOU_KNOW_WHAT_UR_DOING) {
+        for (const [varName, value] of loaded.entries()) {
+            if (value === "true" || value === "false" || value === "") {
+                console.log(`Not masking ${varName}: true/false/empty value`);
+                continue;
+            }
+            console.log(`Masking ${varName}`);
+            console.log(`::add-mask::${value}`);
+        }
+    }
+    return Object.fromEntries(loaded);
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+import { getEnvVariables } from "./env";
+import { generateShortId } from "./short";
+export declare class Utils {
+    static getEnvVariables(...args: Parameters<typeof getEnvVariables>): Promise<Record<string, string>>;
+    static generateShortId(...args: Parameters<typeof generateShortId>): string;
+}

package/dist/utils/index.js

@@ -0,0 +1,10 @@
+import { getEnvVariables } from "./env";
+import { generateShortId } from "./short";
+export class Utils {
+    static getEnvVariables(...args) {
+        return getEnvVariables(...args);
+    }
+    static generateShortId(...args) {
+        return generateShortId(...args);
+    }
+}

package/dist/utils/short.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generate a short ID (default len = 7).
+ *
+ * @note THIS DOES NOT GUARANTEE EXTREMELY LOW COLLISIONS.
+ */
+export declare function generateShortId(len?: number): string;

package/dist/utils/short.js

@@ -0,0 +1,10 @@
+/**
+ * Generate a short ID (default len = 7).
+ *
+ * @note THIS DOES NOT GUARANTEE EXTREMELY LOW COLLISIONS.
+ */
+export function generateShortId(len = 7) {
+    return Math.random()
+        .toString(36)
+        .substring(2, 2 + len);
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@tahminator/pipeline",
+  "type": "module",
+  "version": "1.0.0",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun run typecheck && bun run fmt && bun run lint",
+    "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",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/bun": "latest",
+    "eslint": "^10.0.3",
+    "eslint-plugin-perfectionist": "^5.7.0",
+    "globals": "^17.4.0",
+    "jiti": "^2.6.1",
+    "prettier": "^3.8.1",
+    "typescript-eslint": "^8.57.1",
+    "vitest": "^4.1.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@octokit/rest": "^22.0.1",
+    "@types/semver": "^7.7.1",
+    "semver": "^7.7.4",
+    "yaml": "^2.8.2",
+    "zod": "^4.3.6"
+  }
+}