@vaharoni/devops 1.0.47

package/dist/libs/discovery/images.js

@@ -0,0 +1,45 @@
+import { getWorkspace, workspaceDirectoryForLanguage } from ".";
+import { getImageData, getImageNames } from "../config";
+import { WorkspaceDependencies } from "./dependencies";
+// = From images to workspaces
+const _imageDescendents = {};
+let _imageDescendentsLoaded = false;
+function imageDescendents() {
+    if (!_imageDescendentsLoaded) {
+        for (const imageName of getImageNames()) {
+            const descendents = new Set();
+            const imageData = getImageData(imageName);
+            const workspaces = workspaceDirectoryForLanguage(imageData.language);
+            const dependencyResolver = new WorkspaceDependencies(() => workspaces);
+            imageData.applications.forEach((workspace) => {
+                dependencyResolver.getDependents(workspace).forEach((name) => descendents.add(name));
+            });
+            _imageDescendents[imageName] = Array.from(descendents).map(name => workspaces[name]);
+        }
+        _imageDescendentsLoaded = true;
+    }
+    return _imageDescendents;
+}
+/** The dependent workspaces are specified in config/images.yaml */
+export function getImageDescendentData(imageName) {
+    return (imageDescendents()[imageName] ?? []);
+}
+// = From workspace to images
+const _workspaceImages = {};
+let _workspaceImagesLoaded = false;
+function workspaceImages() {
+    if (!_workspaceImagesLoaded) {
+        for (const [imageName, descendents] of Object.entries(imageDescendents())) {
+            for (const packageData of descendents) {
+                _workspaceImages[packageData.name] ??= [];
+                _workspaceImages[packageData.name].push(imageName);
+            }
+        }
+        _workspaceImagesLoaded = true;
+    }
+    return _workspaceImages;
+}
+export function getWorkspaceImages(workspaceName) {
+    const _verifyPresence = getWorkspace(workspaceName);
+    return workspaceImages()[workspaceName] ?? [];
+}

package/dist/libs/discovery/index.d.ts

@@ -0,0 +1,5 @@
+import type { SupportedLanguages, WorkspaceIndex } from "../../types";
+export declare function workspaces(): WorkspaceIndex;
+export declare function workspaceDirectoryForLanguage(language: SupportedLanguages): Record<string, import("../..").PackageData>;
+export declare function getWorkspace(workspaceName: string): import("../..").WorkspaceIndexEntry;
+//# sourceMappingURL=index.d.ts.map

package/dist/libs/discovery/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAKtE,wBAAgB,UAAU,mBA8BzB;AAED,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,kBAAkB,+CASzE;AAED,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,uCAQjD"}

package/dist/libs/discovery/index.js

@@ -0,0 +1,55 @@
+import chalk from "chalk";
+import { nodeWorkspaces } from "./process-package-json";
+import { pythonWorkspaces } from "./process-pyproject-toml";
+const _workspaces = {};
+let _workspacesLoaded = false;
+export function workspaces() {
+    if (_workspacesLoaded)
+        return _workspaces;
+    const nodeWorkspacesData = nodeWorkspaces();
+    const pythonWorkspacesData = pythonWorkspaces();
+    Object.values(nodeWorkspacesData).forEach(data => {
+        _workspaces[data.name] = {
+            rootPath: data.rootPath,
+            packageDataEntries: [data]
+        };
+    });
+    Object.values(pythonWorkspacesData).forEach(data => {
+        const existing = _workspaces[data.name];
+        if (existing) {
+            if (existing.rootPath !== data.rootPath) {
+                // prettier-ignore
+                console.error(chalk.red(`\nWorkspace ${data.name} has conflicting root paths:\n\t${existing.rootPath}\n\t${data.rootPath}\n`));
+                process.exit(1);
+            }
+        }
+        else {
+            _workspaces[data.name] = {
+                rootPath: data.rootPath,
+                packageDataEntries: []
+            };
+        }
+        _workspaces[data.name].packageDataEntries.push(data);
+    });
+    _workspacesLoaded = true;
+    return _workspaces;
+}
+export function workspaceDirectoryForLanguage(language) {
+    switch (language) {
+        case "node":
+            return nodeWorkspaces();
+        case "python":
+            return pythonWorkspaces();
+        default:
+            throw new Error(`Unsupported language: ${language}`);
+    }
+}
+export function getWorkspace(workspaceName) {
+    const workspace = workspaces()[workspaceName];
+    if (!workspace) {
+        console.error(chalk.red(`\nWorkspace ${workspaceName} not found\n`));
+        // The gha relies on the 13 exit code for "not found"
+        process.exit(13);
+    }
+    return workspace;
+}

package/dist/libs/discovery/package-json-processor.d.ts

@@ -0,0 +1,3 @@
+import { type ProjectData } from "../../types";
+export declare function nodeWorkspaces(): Record<string, ProjectData>;
+//# sourceMappingURL=package-json-processor.d.ts.map

package/dist/libs/discovery/package-json-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json-processor.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/package-json-processor.ts"],"names":[],"mappings":"AAIA,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAUlE,wBAAgB,cAAc,gCAgC7B"}

package/dist/libs/discovery/package-json-processor.js

@@ -0,0 +1,34 @@
+import chalk from "chalk";
+import fs from "fs";
+import { globSync } from "glob";
+import path from "path";
+import { packageJsonSchema } from "../../types";
+const rootPkgJsonPath = path.join(process.cwd(), "package.json");
+const rootPkgJson = JSON.parse(fs.readFileSync(rootPkgJsonPath, "utf8"));
+const _workspaces = {};
+let _workspacesLoaded = false;
+export function nodeWorkspaces() {
+    if (!_workspacesLoaded) {
+        for (const workspaceGlob of (rootPkgJson.workspaces ?? [])) {
+            globSync(path.join(workspaceGlob, "package.json")).forEach((packageJsonPath) => {
+                // Skip packages under node_modules directories in case hoisting did not work
+                if (packageJsonPath.includes("node_modules"))
+                    return;
+                const unsafeData = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+                const parsedRes = packageJsonSchema.safeParse(unsafeData);
+                if (parsedRes.error) {
+                    console.error(`Error parsing ${packageJsonPath}: ${parsedRes.error}`);
+                    process.exit(1);
+                }
+                const { dependencies, ...rest } = parsedRes.data;
+                const dependencyNames = Object.keys(dependencies ?? []);
+                const pkgName = rest.name;
+                const rootPath = path.dirname(packageJsonPath);
+                _workspaces[pkgName] = { data: { ...rest, dependencyNames }, rootPath };
+            });
+        }
+        console.warn(chalk.yellow(`Node workspace discovery initialized. Workspaces found: ${Object.keys(_workspaces).join(", ")}`));
+        _workspacesLoaded = true;
+    }
+    return _workspaces;
+}

package/dist/libs/discovery/process-common.d.ts

@@ -0,0 +1,25 @@
+import type { ZodSchema } from "zod";
+import type { PackageData, SupportedLanguages } from "../../types";
+export declare const IGNORED_PATHS: string[];
+type PackageDataProcessorConfig<T> = {
+    language: SupportedLanguages;
+    pathList: string[];
+    zodSchema: ZodSchema<T>;
+    fileParser: (fileStringData: string) => unknown;
+    nameExtractor: (data: T) => string;
+};
+export declare class PackageDataProcessor<T> {
+    workspaceNames: Set<string>;
+    loadedFiles: Record<string, {
+        name: string;
+        data: T;
+    }>;
+    language: SupportedLanguages;
+    nameExtractor: (data: T) => string;
+    constructor(config: PackageDataProcessorConfig<T>);
+    _runFirstPass(pathList: string[], zodSchema: ZodSchema<T>, fileParser: (fileStringData: string) => unknown): void;
+    filterDependencies(dependencyNames: string[]): string[];
+    convert(iterator: (data: T) => Omit<PackageData, 'rootPath' | 'language' | 'name'>): PackageData[];
+}
+export {};
+//# sourceMappingURL=process-common.d.ts.map

package/dist/libs/discovery/process-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-common.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/process-common.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AACrC,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAInE,eAAO,MAAM,aAAa,UAA6B,CAAC;AAExD,KAAK,0BAA0B,CAAC,CAAC,IAAI;IACnC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACxB,UAAU,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO,CAAC;IAChD,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;CACpC,CAAA;AAED,qBAAa,oBAAoB,CAAC,CAAC;IACjC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAa;IACxC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,CAAC,CAAA;KAAE,CAAC,CAAM;IAC5D,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;gBAEvB,MAAM,EAAE,0BAA0B,CAAC,CAAC,CAAC;IAMjD,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,OAAO;IAiB1G,kBAAkB,CAAC,eAAe,EAAE,MAAM,EAAE;IAI5C,OAAO,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC,GAAG,WAAW,EAAE;CAMnG"}

package/dist/libs/discovery/process-common.js

@@ -0,0 +1,40 @@
+import fs from "fs";
+import path from "path";
+export const IGNORED_PATHS = ["node_modules/", "venv/"];
+export class PackageDataProcessor {
+    workspaceNames = new Set();
+    loadedFiles = {};
+    language;
+    nameExtractor;
+    constructor(config) {
+        this.language = config.language;
+        this.nameExtractor = config.nameExtractor;
+        this._runFirstPass(config.pathList, config.zodSchema, config.fileParser);
+    }
+    _runFirstPass(pathList, zodSchema, fileParser) {
+        pathList.forEach((packageFilePath) => {
+            if (IGNORED_PATHS.find(path => packageFilePath.includes(path)))
+                return;
+            const unsafeData = fileParser(fs.readFileSync(packageFilePath, "utf8"));
+            const parsedRes = zodSchema.safeParse(unsafeData);
+            if (parsedRes.error) {
+                console.error(`Error parsing ${packageFilePath}: ${parsedRes.error}`);
+                process.exit(1);
+            }
+            const rootDir = path.dirname(packageFilePath);
+            const name = this.nameExtractor(parsedRes.data);
+            this.workspaceNames.add(name);
+            this.loadedFiles[rootDir] = { name, data: parsedRes.data };
+        });
+    }
+    // Should be used by the iterator sent to convert in order to filter out dependencies that are not workspaces
+    filterDependencies(dependencyNames) {
+        return dependencyNames.filter((name) => this.workspaceNames.has(name));
+    }
+    convert(iterator) {
+        return Object.entries(this.loadedFiles).map(([rootPath, { name, data }]) => {
+            const res = iterator(data);
+            return { rootPath, language: this.language, name, ...res };
+        });
+    }
+}

package/dist/libs/discovery/process-package-json.d.ts

@@ -0,0 +1,3 @@
+import { type PackageData } from "../../types";
+export declare function nodeWorkspaces(): Record<string, PackageData>;
+//# sourceMappingURL=process-package-json.d.ts.map

package/dist/libs/discovery/process-package-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-package-json.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/process-package-json.ts"],"names":[],"mappings":"AAIA,OAAO,EAAyB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAWtE,wBAAgB,cAAc,gCA+B7B"}

package/dist/libs/discovery/process-package-json.js

@@ -0,0 +1,34 @@
+import chalk from "chalk";
+import fs from "fs";
+import { globSync } from "glob";
+import path from "path";
+import { packageFileNodeSchema } from "../../types";
+import { PackageDataProcessor } from "./process-common";
+const rootPkgJsonPath = path.join(process.cwd(), "package.json");
+const rootPkgJson = JSON.parse(fs.readFileSync(rootPkgJsonPath, "utf8"));
+const _workspaces = {};
+let _workspacesLoaded = false;
+export function nodeWorkspaces() {
+    if (!_workspacesLoaded) {
+        const allPackageJsons = (rootPkgJson.workspaces ?? []).flatMap((workspaceGlob) => globSync(path.join(workspaceGlob, "package.json")));
+        const processor = new PackageDataProcessor({
+            language: "node",
+            pathList: allPackageJsons,
+            zodSchema: packageFileNodeSchema,
+            fileParser: JSON.parse,
+            nameExtractor: (data) => data.name,
+        });
+        processor.convert((data) => {
+            const { dependencies, ...rest } = data;
+            const dependencyNames = Object.keys(dependencies ?? []);
+            return { ...rest, dependencyNames: processor.filterDependencies(dependencyNames) };
+        }).forEach(pkgData => {
+            _workspaces[pkgData.name] = pkgData;
+        });
+        console.warn(chalk.yellow(
+        // prettier-ignore
+        `Node workspace discovery initialized. Workspaces found: ${Object.keys(_workspaces).join(", ")}`));
+        _workspacesLoaded = true;
+    }
+    return _workspaces;
+}

package/dist/libs/discovery/process-pyproject-toml.d.ts

@@ -0,0 +1,3 @@
+import { type PackageData } from "../../types";
+export declare function pythonWorkspaces(): Record<string, PackageData>;
+//# sourceMappingURL=process-pyproject-toml.d.ts.map

package/dist/libs/discovery/process-pyproject-toml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-pyproject-toml.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/process-pyproject-toml.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2B,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAOxE,wBAAgB,gBAAgB,gCAiC/B"}

package/dist/libs/discovery/process-pyproject-toml.js

@@ -0,0 +1,36 @@
+import chalk from "chalk";
+import { globSync } from "glob";
+import { packageFilePythonSchema } from "../../types";
+import { PackageDataProcessor } from "./process-common";
+import TOML from '@iarna/toml';
+const _workspaces = {};
+let _workspacesLoaded = false;
+export function pythonWorkspaces() {
+    if (!_workspacesLoaded) {
+        const allPyprojectTomls = globSync("**/*/pyproject.toml");
+        const processor = new PackageDataProcessor({
+            language: "python",
+            pathList: allPyprojectTomls,
+            zodSchema: packageFilePythonSchema,
+            fileParser: TOML.parse,
+            nameExtractor: (data) => data.project.name,
+        });
+        processor.convert((data) => {
+            const deployment = data.tool?.devops?.deployment;
+            const scripts = data.tool?.devops?.scripts;
+            const dependencyNames = data.project.dependencies ?? [];
+            return {
+                scripts,
+                deployment,
+                dependencyNames: processor.filterDependencies(dependencyNames)
+            };
+        }).forEach(pkgData => {
+            _workspaces[pkgData.name] = pkgData;
+        });
+        console.warn(chalk.yellow(
+        // prettier-ignore
+        `Python workspace discovery initialized. Workspaces found: ${Object.keys(_workspaces).join(", ")}`));
+        _workspacesLoaded = true;
+    }
+    return _workspaces;
+}

package/dist/libs/discovery/pyproject-toml-processor.d.ts

@@ -0,0 +1,3 @@
+import { type ProjectData } from "../../types";
+export declare function pythonWorkspaces(): Record<string, ProjectData>;
+//# sourceMappingURL=pyproject-toml-processor.d.ts.map

package/dist/libs/discovery/pyproject-toml-processor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyproject-toml-processor.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/pyproject-toml-processor.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AAMhE,wBAAgB,gBAAgB,gCAsC/B"}

package/dist/libs/discovery/pyproject-toml-processor.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+import fs from "fs";
+import { globSync } from "glob";
+import path from "path";
+import { pyProjectSchema } from "../../types";
+import TOML from '@iarna/toml';
+const _workspaces = {};
+let _workspacesLoaded = false;
+export function pythonWorkspaces() {
+    if (!_workspacesLoaded) {
+        globSync(path.join(process.cwd(), "**/*/pyproject.toml")).forEach((pyProjectPath) => {
+            // Skip packages under venv just in case
+            if (pyProjectPath.includes("venv"))
+                return;
+            const unsafeData = TOML.parse(fs.readFileSync(pyProjectPath, "utf8"));
+            const parsedRes = pyProjectSchema.safeParse(unsafeData);
+            if (parsedRes.error) {
+                console.error(`Error parsing ${pyProjectPath}: ${parsedRes.error}`);
+                process.exit(1);
+            }
+            const data = parsedRes.data;
+            const pkgName = data.project.name;
+            const deployment = data.tool?.devops?.deployment;
+            const rootPath = path.dirname(pyProjectPath);
+            _workspaces[pkgName] = {
+                rootPath,
+                data: {
+                    name: pkgName,
+                    scripts: data.tool?.poetry?.scripts,
+                    dependencyNames: Object.keys(data.tool?.poetry?.dependencies ?? []),
+                    deployment,
+                }
+            };
+        });
+        console.warn(chalk.yellow(`Python workspace discovery initialized. Workspaces found: ${Object.keys(_workspaces).join(", ")}`));
+        _workspacesLoaded = true;
+    }
+    return _workspaces;
+}

package/dist/libs/git-helpers.d.ts

@@ -0,0 +1,8 @@
+export declare function commitExists(sha: string): boolean;
+export declare function firstCommit(): string;
+export declare function isAffected(path: string, opts?: {
+    baseSha?: string;
+    headSha?: string;
+    skipCheck?: boolean;
+}): boolean;
+//# sourceMappingURL=git-helpers.d.ts.map

package/dist/libs/git-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-helpers.d.ts","sourceRoot":"","sources":["../../src/libs/git-helpers.ts"],"names":[],"mappings":"AAEA,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,WAKvC;AAED,wBAAgB,WAAW,WAK1B;AAED,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,OAAO,CAAA;CAAO,WAavE"}

package/dist/libs/git-helpers.js

@@ -0,0 +1,20 @@
+import { CommandExecutor } from "../cli/common";
+export function commitExists(sha) {
+    const statusCode = new CommandExecutor(`git merge-base --is-ancestor "${sha}" HEAD`).exec({ onlyStatusCode: true });
+    return statusCode === 0;
+}
+export function firstCommit() {
+    const res = new CommandExecutor(`git rev-list --max-parents=0 HEAD`, {
+        quiet: true,
+    }).exec();
+    return res?.trim();
+}
+export function isAffected(path, opts = {}) {
+    const baseSha = opts.baseSha || "HEAD^";
+    const headSha = opts.headSha || "HEAD";
+    // When in doubt, assume it's affected
+    if (!opts.skipCheck && (!commitExists(baseSha) || !commitExists(headSha)))
+        return true;
+    const statusCode = new CommandExecutor(`git diff --quiet ${baseSha} ${headSha} -- ${path}`, { quiet: true }).exec({ onlyStatusCode: true });
+    return statusCode !== 0;
+}

package/dist/libs/hetzner/reg-secret.d.ts

@@ -0,0 +1,3 @@
+export declare function copySecretHarborToNamespace(monorepoEnv: string): void;
+export declare function patchServiceAccountImagePullSecret(monorepoEnv: string): void;
+//# sourceMappingURL=reg-secret.d.ts.map

package/dist/libs/hetzner/reg-secret.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reg-secret.d.ts","sourceRoot":"","sources":["../../../src/libs/hetzner/reg-secret.ts"],"names":[],"mappings":"AAgBA,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,MAAM,QA2B9D;AAED,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,MAAM,QAQrE"}

package/dist/libs/hetzner/reg-secret.js

@@ -0,0 +1,39 @@
+import { CommandExecutor } from "../../cli/common";
+import { getConst } from "../config";
+import { envToNamespace } from "../k8s-constants";
+import { kubectlCommand } from "../k8s-helpers";
+function isApplicable() {
+    const infra = getConst("infra");
+    if (infra !== "hetzner") {
+        console.warn("Setting up registry permissions is only needed for Harbor in a Hetzner setup");
+        return false;
+    }
+    return true;
+}
+export function copySecretHarborToNamespace(monorepoEnv) {
+    if (!isApplicable())
+        return;
+    const cmd = kubectlCommand("get secret harbor-registry-secret -o json", {
+        monorepoEnv,
+        namespace: "harbor",
+    });
+    const secretStr = new CommandExecutor(cmd, { quiet: true }).exec();
+    const secretJson = JSON.parse(secretStr);
+    const { apiVersion, data, kind, metadata: { name }, type, } = secretJson;
+    const relevantParts = {
+        apiVersion,
+        data,
+        kind,
+        metadata: { name, namespace: envToNamespace(monorepoEnv) },
+        type,
+    };
+    // prettier-ignore
+    const copyCmd = `echo '${JSON.stringify(relevantParts)}' | kubectl apply -f -`;
+    new CommandExecutor(copyCmd, { quiet: true }).exec();
+}
+export function patchServiceAccountImagePullSecret(monorepoEnv) {
+    if (!isApplicable())
+        return;
+    const cmd = kubectlCommand(`patch serviceaccount default -p '{"imagePullSecrets": [{"name": "harbor-registry-secret"}]}'`, { monorepoEnv });
+    new CommandExecutor(cmd, { quiet: true }).exec();
+}

package/dist/libs/k8s-constants.d.ts

@@ -0,0 +1,12 @@
+export declare const MISSING_DOMAIN_KEY_ERROR = "$$$MISSING_DOMAIN_KEY$$$";
+export declare function allSupportedEnvs(): string[];
+export declare function envToNamespace(monorepoEnv?: string): string;
+export declare function secretName(): string;
+export declare function imageDebugName(image: string): string;
+export declare function imageConfigMap(image: string): string;
+export declare function containerRegistryRepoName(image: string, monorepoEnv: string): string;
+export declare function containerRegistryPath(): string;
+export declare function containerRegistryRepoPath(image: string, monorepoEnv: string, gitSha: string): string;
+export declare function domainNameForEnv(image: string, monorepoEnv: string): string;
+export declare function dbMigrateJobName(gitSha: string): string;
+//# sourceMappingURL=k8s-constants.d.ts.map

package/dist/libs/k8s-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-constants.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,wBAAwB,6BAA6B,CAAA;AAoBlE,wBAAgB,gBAAgB,aAE/B;AAYD,wBAAgB,cAAc,CAAC,WAAW,CAAC,EAAE,MAAM,UAGlD;AAED,wBAAgB,UAAU,WAEzB;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,UAE3C;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,UAE3C;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,UAG3E;AAED,wBAAgB,qBAAqB,WAEpC;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,UAOf;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,UAIlE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,UAE9C"}

package/dist/libs/k8s-constants.js

@@ -0,0 +1,66 @@
+import { getConst, getImageData } from "./config";
+export const MISSING_DOMAIN_KEY_ERROR = "$$$MISSING_DOMAIN_KEY$$$";
+const DEFAULT_REMOTE_ENVS = ["staging", "production"];
+const DEFAULT_LOCAL_ENVS = ["development", "test"];
+let _remoteSupportedEnvs;
+function remoteSupportedEnvs() {
+    if (_remoteSupportedEnvs)
+        return _remoteSupportedEnvs;
+    const extra = getConst("extra-remote-environments", { ignoreIfInvalid: true }) ?? [];
+    _remoteSupportedEnvs = [...DEFAULT_REMOTE_ENVS, ...extra];
+    return _remoteSupportedEnvs;
+}
+let _localSupportedEnvs;
+function localSupportedEnvs() {
+    if (_localSupportedEnvs)
+        return _localSupportedEnvs;
+    const extra = getConst("extra-local-environments", { ignoreIfInvalid: true }) ?? [];
+    _localSupportedEnvs = [...DEFAULT_LOCAL_ENVS, ...extra];
+    return _localSupportedEnvs;
+}
+export function allSupportedEnvs() {
+    return [...remoteSupportedEnvs(), ...localSupportedEnvs()];
+}
+function validateEnv(monorepoEnv) {
+    if (!monorepoEnv)
+        throw new Error("MONOREPO_ENV cannot be empty");
+    if (!remoteSupportedEnvs().includes(monorepoEnv)) {
+        console.error(`MONOREPO_ENV must be one of: ${remoteSupportedEnvs().join(", ")}. Can be set using --env flag.`);
+        process.exit(1);
+    }
+}
+export function envToNamespace(monorepoEnv) {
+    validateEnv(monorepoEnv);
+    return `${getConst("project-name")}-${monorepoEnv}`;
+}
+export function secretName() {
+    return `${getConst("project-name")}-secret`;
+}
+export function imageDebugName(image) {
+    return `${image}-debug`;
+}
+export function imageConfigMap(image) {
+    return `image-config-${image}`;
+}
+export function containerRegistryRepoName(image, monorepoEnv) {
+    validateEnv(monorepoEnv);
+    return `${getConst("project-name")}-${monorepoEnv}-${image}`;
+}
+export function containerRegistryPath() {
+    return [getConst("registry-base-url"), getConst("registry-name")].join("/");
+}
+export function containerRegistryRepoPath(image, monorepoEnv, gitSha) {
+    return [
+        getConst("registry-base-url"),
+        getConst("registry-name"),
+        [containerRegistryRepoName(image, monorepoEnv), gitSha].join(":"),
+    ].join("/");
+}
+export function domainNameForEnv(image, monorepoEnv) {
+    const imageData = getImageData(image);
+    const value = imageData["domains"]?.[monorepoEnv] ?? MISSING_DOMAIN_KEY_ERROR;
+    return value;
+}
+export function dbMigrateJobName(gitSha) {
+    return `db-migrate-job-${gitSha.slice(0, 8)}`;
+}

package/dist/libs/k8s-db.d.ts

@@ -0,0 +1,18 @@
+export declare function getDbList(): string | null;
+export declare function getDbBackups(): string | null;
+export declare function getDbAdminPassword(): {
+    user: string;
+    password: string;
+} | null;
+export declare function getDbPasswords(namespace: string): {
+    superUser: string;
+    superPassword: string;
+    authenticatorUser: string;
+    authenticatorPassword: string;
+    replicationUser: string;
+    replicationPassword: string;
+} | null;
+export declare function connectToPatroni(namespace: string): void;
+export declare function connectToPsql(namespace: string): void;
+export declare function establishTunnel(namespace: string, port: string): void;
+//# sourceMappingURL=k8s-db.d.ts.map

package/dist/libs/k8s-db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-db.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-db.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,kBAKxB;AAED,wBAAgB,YAAY,kBAK3B;AAED,wBAAgB,kBAAkB;;;SAejC;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM;;;;;;;SAyB/C;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,QAMjD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,QAM9C;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAK9D"}

package/dist/libs/k8s-db.js

@@ -0,0 +1,73 @@
+import { CommandExecutor } from "../cli/common";
+import { kubectlCommand } from "./k8s-helpers";
+export function getDbList() {
+    const cmd = kubectlCommand(`get sgcluster -A`);
+    const res = new CommandExecutor(cmd, { quiet: true }).exec();
+    if (!res)
+        return null;
+    return res;
+}
+export function getDbBackups() {
+    const cmd = kubectlCommand(`get sgbkp -A`);
+    const res = new CommandExecutor(cmd, { quiet: true }).exec();
+    if (!res)
+        return null;
+    return res;
+}
+export function getDbAdminPassword() {
+    const cmd = kubectlCommand(`get secrets/stackgres-restapi-admin -o jsonpath="{.data}"`, { namespace: "stackgres" });
+    const res = new CommandExecutor(cmd, { quiet: true }).exec();
+    if (!res)
+        return null;
+    try {
+        const resJson = JSON.parse(res);
+        const password = atob(resJson["clearPassword"]);
+        const user = atob(resJson["k8sUsername"]);
+        return { user, password };
+    }
+    catch {
+        return null;
+    }
+}
+export function getDbPasswords(namespace) {
+    const cmd = kubectlCommand(`get secrets/${namespace} -o jsonpath="{.data}"`, {
+        namespace,
+    });
+    const res = new CommandExecutor(cmd, { quiet: true }).exec();
+    if (!res)
+        return null;
+    try {
+        const resJson = JSON.parse(res);
+        const superUser = atob(resJson["superuser-username"]);
+        const superPassword = atob(resJson["superuser-password"]);
+        const authenticatorUser = atob(resJson["authenticator-username"]);
+        const authenticatorPassword = atob(resJson["authenticator-password"]);
+        const replicationUser = atob(resJson["replication-username"]);
+        const replicationPassword = atob(resJson["replication-password"]);
+        return {
+            superUser,
+            superPassword,
+            authenticatorUser,
+            authenticatorPassword,
+            replicationUser,
+            replicationPassword,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function connectToPatroni(namespace) {
+    const cmd = kubectlCommand(`exec -it ${namespace}-0 -c patroni -- /bin/bash`, { namespace });
+    new CommandExecutor(cmd).spawn();
+}
+export function connectToPsql(namespace) {
+    const cmd = kubectlCommand(`exec -it ${namespace}-0 -c postgres-util -- psql`, { namespace });
+    new CommandExecutor(cmd).spawn();
+}
+export function establishTunnel(namespace, port) {
+    const cmd = kubectlCommand(`port-forward pod/${namespace}-0 ${port}:5432`, {
+        namespace,
+    });
+    new CommandExecutor(cmd).spawn();
+}

package/dist/libs/k8s-generate.d.ts

@@ -0,0 +1,17 @@
+import type { PackageData, TemplateDbMigrateObject, TemplateDebugObject, TemplateDeploymentObject, TemplateSharedContext } from "../types";
+export declare function generateImageDeployments(monorepoEnv: string, image: string, gitSha: string): string;
+export declare function generateWorkspaceDeployment(packageData: PackageData, monorepoEnv: string, image: string, gitSha: string): string;
+export declare function generateDebugDeployment(monorepoEnv: string, image: string, gitSha: string): string;
+export declare function generateDbMigrateJob(monorepoEnv: string, image: string, gitSha: string): string;
+export declare class ImageContextGenerator {
+    monorepoEnv: string;
+    image: string;
+    gitSha: string;
+    replicaMap: Record<string, number>;
+    imageContext: Omit<TemplateSharedContext, 'project_name'>;
+    constructor(monorepoEnv: string, image: string, gitSha: string);
+    getDeployment(pkgData: PackageData): TemplateDeploymentObject;
+    getDbMigrate(): TemplateDbMigrateObject;
+    getDebug(): TemplateDebugObject;
+}
+//# sourceMappingURL=k8s-generate.d.ts.map