@vaharoni/devops 1.0.47

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

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-generate.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAqB3I,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,UAaf;AAED,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,UAMvH;AAED,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,UAOf;AAED,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,UAMf;AA6FD,qBAAa,qBAAqB;IAIb,WAAW,EAAE,MAAM;IAAS,KAAK,EAAE,MAAM;IAAS,MAAM,EAAE,MAAM;IAHnF,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,YAAY,EAAE,IAAI,CAAC,qBAAqB,EAAE,cAAc,CAAC,CAAC;gBAEvC,WAAW,EAAE,MAAM,EAAS,KAAK,EAAE,MAAM,EAAS,MAAM,EAAE,MAAM;IAYnF,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,wBAAwB;IAmB7D,YAAY,IAAI,uBAAuB;IAOvC,QAAQ,IAAI,mBAAmB;CAMhC"}

package/dist/libs/k8s-generate.js

@@ -0,0 +1,179 @@
+import { BASE_SECRET_KEY } from "./k8s-namespace";
+import { containerRegistryRepoPath, dbMigrateJobName, domainNameForEnv, envToNamespace, imageDebugName, MISSING_DOMAIN_KEY_ERROR, secretName } from "./k8s-constants";
+import { getWorkspaceScale } from "./k8s-image-config";
+import path from "path";
+import yaml from "yaml";
+import fs from 'fs';
+import { globSync } from "glob";
+import _, { template } from 'lodash';
+import Handlebars from "handlebars";
+import { getImageData } from "./config";
+import { getImageDescendentData } from "./discovery/images";
+const MANIFEST_FOLDER_PATH = path.join(process.cwd(), '.devops/manifests');
+const MANIFEST_INDEX_FILE_PATH = path.join(MANIFEST_FOLDER_PATH, '_index.yaml');
+const DB_MIGRATE_TEMPLATE_NAME = 'db-migrate';
+// = Interface
+export function generateImageDeployments(monorepoEnv, image, gitSha) {
+    const generator = new ImageContextGenerator(monorepoEnv, image, gitSha);
+    const apps = getImageDescendentData(image)
+        .filter((packageData) => packageData.deployment)
+        .flatMap((projectData) => {
+        const context = generator.getDeployment(projectData);
+        const renderFn = (template) => Handlebars.compile(template)(context);
+        return generateManifestForDeployment(projectData.rootPath, projectData.deployment.template, renderFn);
+    });
+    const debug = generateDebugDeployment(monorepoEnv, image, gitSha);
+    const manifest = [debug, ...apps].join("\n---\n");
+    return ensureProperDomainsPresent(manifest, monorepoEnv, image);
+}
+export function generateWorkspaceDeployment(packageData, monorepoEnv, image, gitSha) {
+    const generator = new ImageContextGenerator(monorepoEnv, image, gitSha);
+    const context = generator.getDeployment(packageData);
+    const renderFn = (template) => Handlebars.compile(template)(context);
+    const manifest = generateManifestForDeployment(packageData.rootPath, packageData.deployment.template, renderFn).join("\n---\n");
+    return ensureProperDomainsPresent(manifest, monorepoEnv, image);
+}
+export function generateDebugDeployment(monorepoEnv, image, gitSha) {
+    const generator = new ImageContextGenerator(monorepoEnv, image, gitSha);
+    const context = generator.getDebug();
+    const renderFn = (template) => Handlebars.compile(template)(context);
+    const debugTemplate = getImageData(image)["debug-template"];
+    return generateManifestsFromTemplateName(debugTemplate, renderFn).map(x => yaml.stringify(x)).join("\n---\n");
+}
+export function generateDbMigrateJob(monorepoEnv, image, gitSha) {
+    const generator = new ImageContextGenerator(monorepoEnv, image, gitSha);
+    const context = generator.getDbMigrate();
+    const renderFn = (template) => Handlebars.compile(template)(context);
+    return generateManifestsFromTemplateName(DB_MIGRATE_TEMPLATE_NAME, renderFn).map(x => yaml.stringify(x)).join("\n---\n");
+}
+// = Verification
+function ensureProperDomainsPresent(manifest, monorepoEnv, image) {
+    if (manifest.includes(MISSING_DOMAIN_KEY_ERROR)) {
+        console.error(`The image ${image} does not have a domain defined for the environment ${monorepoEnv}. Please add it to the .devops/config/images.yaml.`);
+        process.exit(1);
+    }
+    return manifest;
+}
+// = Generation logic
+// L1 generation: composite
+function generateManifestForDeployment(rootPath, templateName, renderFn) {
+    const defaults = generateManifestsFromTemplateName(templateName, renderFn);
+    const overrides = generateManifestFromFilesInFolder(rootPath, renderFn);
+    const keyExtractor = (manifest) => `${manifest.kind}-${manifest.metadata.name}`;
+    const defaultTemplateLookup = _.keyBy(defaults, keyExtractor);
+    const overrideTemplateLookup = _.keyBy(overrides, keyExtractor);
+    const mergedTemplates = _.merge(defaultTemplateLookup, overrideTemplateLookup);
+    return Object.values(mergedTemplates).map(x => yaml.stringify(x));
+}
+// L2 generation
+function generateManifestsFromTemplateName(templateName, renderFn) {
+    const entries = manifestFilesForTemplate(templateName);
+    if (!entries) {
+        console.error(`No entries found for ${templateName} in ${MANIFEST_INDEX_FILE_PATH}`);
+        process.exit(1);
+    }
+    return generateManifestsFromFileList(entries.map(entry => path.join(MANIFEST_FOLDER_PATH, entry)), renderFn);
+}
+// L2 generation
+function generateManifestFromFilesInFolder(folderPath, renderFn) {
+    const manifestOverridePath = path.join(folderPath, 'manifests');
+    if (!fs.existsSync(manifestOverridePath)) {
+        return [];
+    }
+    const files = globSync(path.join(manifestOverridePath, '**/*')).filter(x => fs.lstatSync(x).isFile());
+    return generateManifestsFromFileList(files, renderFn);
+}
+// L3 generation
+function generateManifestsFromFileList(filesList, renderFn) {
+    return filesList.flatMap((filePath) => {
+        try {
+            const manifestFileStr = fs.readFileSync(filePath, 'utf8');
+            const renderedStr = renderFn(manifestFileStr);
+            const res = yaml.parseAllDocuments(renderedStr);
+            res.forEach((doc) => {
+                if (!doc.get("kind") || !doc.getIn(["metadata", "name"])) {
+                    console.error(`Invalid manifest file ${filePath}: kind and metadata.name must be present`);
+                    console.error(doc.toString());
+                    process.exit(1);
+                }
+            });
+            return res.map(x => x.toJSON());
+        }
+        catch (e) {
+            if (e instanceof Error) {
+                console.error(`Could not parse ${filePath}: ${e.message}`);
+            }
+            else {
+                console.error(`Could not parse ${filePath}`);
+            }
+            process.exit(1);
+        }
+    });
+}
+// Infra: the template index file
+let _manifestIndex;
+function manifestFilesForTemplate(template) {
+    if (!_manifestIndex) {
+        try {
+            const indexFileStr = fs.readFileSync(MANIFEST_INDEX_FILE_PATH, 'utf8');
+            _manifestIndex = yaml.parse(indexFileStr);
+        }
+        catch {
+            console.error(`Unable to process ${MANIFEST_INDEX_FILE_PATH}`);
+            process.exit(1);
+        }
+    }
+    return _manifestIndex[template];
+}
+// Infra: the image context generator
+export class ImageContextGenerator {
+    monorepoEnv;
+    image;
+    gitSha;
+    replicaMap;
+    imageContext;
+    constructor(monorepoEnv, image, gitSha) {
+        this.monorepoEnv = monorepoEnv;
+        this.image = image;
+        this.gitSha = gitSha;
+        this.replicaMap = getWorkspaceScale(monorepoEnv, image);
+        this.imageContext = {
+            monorepo_env: monorepoEnv,
+            namespace: envToNamespace(monorepoEnv),
+            env_secret_name: secretName(),
+            env_base_secret_key: BASE_SECRET_KEY,
+            domain_name: domainNameForEnv(image, monorepoEnv),
+            image_path: containerRegistryRepoPath(image, monorepoEnv, gitSha),
+        };
+    }
+    getDeployment(pkgData) {
+        if (!pkgData.deployment) {
+            console.error(`The deployment key is missing for workspace ${pkgData.name}`);
+            process.exit(1);
+        }
+        return {
+            // Basic context
+            project_name: pkgData.name,
+            ...this.imageContext,
+            // Defaults that can be overriden by pkgData.deployment
+            app_name: pkgData.name,
+            subdomain: pkgData.deployment.service_name,
+            // This may override the defaults above
+            ...pkgData.deployment,
+            // Override from config map
+            replicas: this.replicaMap[pkgData.name] ?? 1,
+        };
+    }
+    getDbMigrate() {
+        return {
+            ...this.imageContext,
+            db_migrate_job_name: dbMigrateJobName(this.gitSha),
+        };
+    }
+    getDebug() {
+        return {
+            ...this.imageContext,
+            debug_pod_name: imageDebugName(this.image)
+        };
+    }
+}

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

@@ -0,0 +1,11 @@
+export declare function kubectlCommand(cmd: string, opts?: {
+    monorepoEnv?: string;
+    namespace?: string;
+}): string;
+export declare function upsertConfigMapCommand(monorepoEnv: string, configMapName: string, data: Record<string, string>): string;
+export declare function patchSecretKeyCommand(monorepoEnv: string, secretName: string, secretKey: string, secretValue: string): {
+    fullCommand: string;
+    redactedCommand: string;
+};
+export declare function applyHandler(filePrefix: string, command: "apply" | "delete", manifest: string): void;
+//# sourceMappingURL=k8s-helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-helpers.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-helpers.ts"],"names":[],"mappings":"AAMA,wBAAgB,cAAc,CAC5B,GAAG,EAAE,MAAM,EACX,IAAI,GAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,UAQxD;AAED,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,UAe9G;AAED,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;;;EAUpH;AAED,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,OAAO,GAAG,QAAQ,EAC3B,QAAQ,EAAE,MAAM,QAQjB"}

package/dist/libs/k8s-helpers.js

@@ -0,0 +1,42 @@
+import { CommandExecutor } from "../cli/common";
+import { envToNamespace } from "./k8s-constants";
+import fs from "fs";
+const TMP_MANIFEST_FOLDER = "tmp/k8s-manifests";
+export function kubectlCommand(cmd, opts = {}) {
+    if (opts.monorepoEnv || opts.namespace) {
+        const namespace = opts.namespace ?? envToNamespace(opts.monorepoEnv);
+        return `kubectl -n ${namespace} ${cmd}`;
+    }
+    else {
+        return `kubectl ${cmd}`;
+    }
+}
+export function upsertConfigMapCommand(monorepoEnv, configMapName, data) {
+    const manifest = {
+        apiVersion: 'v1',
+        kind: 'ConfigMap',
+        metadata: {
+            name: configMapName,
+            namespace: envToNamespace(monorepoEnv),
+            labels: {
+                env: monorepoEnv
+            }
+        },
+        data
+    };
+    const applyCmd = kubectlCommand(`apply -f -`, { monorepoEnv });
+    return `echo '${JSON.stringify(manifest)}' | ${applyCmd}`;
+}
+export function patchSecretKeyCommand(monorepoEnv, secretName, secretKey, secretValue) {
+    const redactedCommand = kubectlCommand(`patch secret ${secretName} -p='{"stringData": {"${secretKey}": **REDACTED**}}'`, { monorepoEnv });
+    const fullCommand = redactedCommand.replace("**REDACTED**", JSON.stringify(secretValue));
+    return { fullCommand, redactedCommand };
+}
+export function applyHandler(filePrefix, command, manifest) {
+    if (!fs.existsSync(TMP_MANIFEST_FOLDER)) {
+        fs.mkdirSync(TMP_MANIFEST_FOLDER, { recursive: true });
+    }
+    const path = `${TMP_MANIFEST_FOLDER}/${filePrefix}-${Date.now()}.yaml`;
+    fs.writeFileSync(path, manifest);
+    new CommandExecutor(kubectlCommand(`${command} -f ${path}`)).exec();
+}

package/dist/libs/k8s-image-config.d.ts

@@ -0,0 +1,8 @@
+export declare function getImageVersion(monorepoEnv: string, image: string): string | undefined;
+export declare function setImageVersion(monorepoEnv: string, image: string, version: string): string;
+export declare function deleteImageVersion(monorepoEnv: string, image: string): string;
+export declare function setWorkspaceScale(monorepoEnv: string, image: string, workspaceName: string, replicaCount: number): number | undefined;
+export declare function getWorkspaceScale(monorepoEnv: string, image: string): Record<string, number>;
+export declare function getWorkspaceScale(monorepoEnv: string, image: string, workspaceName: string): number;
+export declare function resetWorkspaceScale(monorepoEnv: string, image: string, workspaceName?: string): number | Record<string, number>;
+//# sourceMappingURL=k8s-image-config.d.ts.map

package/dist/libs/k8s-image-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-image-config.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-image-config.ts"],"names":[],"mappings":"AAqDA,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,sBAGjE;AAED,wBAAgB,eAAe,CAC7B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,UAIhB;AAED,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,UAGpE;AA2BD,wBAAgB,iBAAiB,CAC/B,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,sBAuBrB;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAC9F,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAAC;AAcrG,wBAAgB,mBAAmB,CACjC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,aAAa,CAAC,EAAE,MAAM,mCAoBvB"}

package/dist/libs/k8s-image-config.js

@@ -0,0 +1,113 @@
+import { CommandExecutor } from "../cli/common";
+import { getWorkspace } from "./discovery";
+import { imageConfigMap } from "./k8s-constants";
+import { kubectlCommand, upsertConfigMapCommand } from "./k8s-helpers";
+function updateImageConfigMap(monorepoEnv, image, data = {}) {
+    const imageConfigMapName = imageConfigMap(image);
+    return new CommandExecutor(upsertConfigMapCommand(monorepoEnv, imageConfigMapName, data)).exec();
+}
+function getImageConfigMap(monorepoEnv, image) {
+    const imageConfigMapName = imageConfigMap(image);
+    const { statusCode, stdout } = new CommandExecutor(kubectlCommand(`get configmap ${imageConfigMapName} -o jsonpath='{.data}'`, { monorepoEnv }), { quiet: true }).exec({ asObject: true });
+    if (statusCode !== 0 || !stdout)
+        return {};
+    try {
+        return JSON.parse(stdout);
+    }
+    catch {
+        console.error(`Error parsing config map data for ${image}. Received: ${stdout}`);
+        process.exit(1);
+    }
+}
+function deserializeImageConfigMapKey(monorepoEnv, image, key) {
+    const value = getImageConfigMap(monorepoEnv, image)[key];
+    if (!value)
+        return {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        console.error(`Error parsing config map data for ${image} for key ${key}. Received: ${value}`);
+        process.exit(1);
+    }
+}
+// = Version
+export function getImageVersion(monorepoEnv, image) {
+    const data = getImageConfigMap(monorepoEnv, image);
+    return data.version;
+}
+export function setImageVersion(monorepoEnv, image, version) {
+    const data = getImageConfigMap(monorepoEnv, image);
+    return updateImageConfigMap(monorepoEnv, image, { ...data, version });
+}
+export function deleteImageVersion(monorepoEnv, image) {
+    const { version, ...rest } = getImageConfigMap(monorepoEnv, image);
+    return updateImageConfigMap(monorepoEnv, image, rest);
+}
+// = Scale
+function setK8sScale(monorepoEnv, workspaceName, replicaCount) {
+    const workspaceData = getWorkspace(workspaceName);
+    const serviceName = workspaceData.packageDataEntries.find(x => x.deployment?.service_name)?.deployment?.service_name;
+    if (!serviceName) {
+        console.error(`Workspace ${workspaceName} must have a service_name defined in its deployment key in package.json. Skipping.`);
+        return false;
+    }
+    new CommandExecutor(kubectlCommand(`scale deployment ${workspaceName} --replicas=${replicaCount}`, { monorepoEnv })).exec();
+    return true;
+}
+// Returns the old version prior to setting
+export function setWorkspaceScale(monorepoEnv, image, workspaceName, replicaCount) {
+    const workspaceData = getWorkspace(workspaceName);
+    if (!workspaceData.packageDataEntries.find(x => x.deployment)) {
+        console.error(`Workspace ${workspaceName} does not have deployment data.`);
+        process.exit(1);
+    }
+    if (replicaCount < 1) {
+        console.error("Replica count must be at least 1.");
+        process.exit(1);
+    }
+    const { scale: _scale, ...rest } = getImageConfigMap(monorepoEnv, image);
+    const parsedScale = deserializeImageConfigMapKey(monorepoEnv, image, "scale");
+    const isApplicable = setK8sScale(monorepoEnv, workspaceName, replicaCount);
+    if (!isApplicable)
+        return;
+    updateImageConfigMap(monorepoEnv, image, {
+        ...rest,
+        scale: JSON.stringify({
+            ...parsedScale,
+            [workspaceName]: replicaCount,
+        }),
+    });
+    return parsedScale?.[workspaceName] ?? 1;
+}
+export function getWorkspaceScale(monorepoEnv, image, 
+/** If not provided, returns all workspaces */
+workspaceName) {
+    const parsedScale = deserializeImageConfigMapKey(monorepoEnv, image, "scale");
+    if (!workspaceName)
+        return parsedScale ?? {};
+    const _ensureWorkspace = getWorkspace(workspaceName);
+    return parsedScale?.[workspaceName] ?? 1;
+}
+// /** Returns the old scale prior to deletion */
+export function resetWorkspaceScale(monorepoEnv, image, workspaceName) {
+    const { scale: _scale, ...rest } = getImageConfigMap(monorepoEnv, image);
+    const parsedScale = deserializeImageConfigMapKey(monorepoEnv, image, "scale");
+    if (!workspaceName) {
+        updateImageConfigMap(monorepoEnv, image, rest);
+        Object.entries(parsedScale ?? {})
+            .filter(([_name, scale]) => Number(scale) > 1)
+            .forEach(([name, _scale]) => {
+            setK8sScale(monorepoEnv, name, 1);
+        });
+        return parsedScale;
+    }
+    else {
+        const oldScale = parsedScale?.[workspaceName] ?? 1;
+        const newScale = { ...parsedScale };
+        delete newScale[workspaceName];
+        updateImageConfigMap(monorepoEnv, image, { ...rest, scale: JSON.stringify(newScale) });
+        setK8sScale(monorepoEnv, workspaceName, 1);
+        return oldScale;
+    }
+}

package/dist/libs/k8s-job-waiter.d.ts

@@ -0,0 +1,8 @@
+export type JobStatuses = Record<string, {
+    status: "success" | "failure" | "timeout";
+    elapsed: number;
+    error?: string;
+}>;
+export declare function k8sJobWaiter(monorepoEnv: string, timeoutInS: number, jobs: string[]): Promise<JobStatuses>;
+export declare function printJobStatuses(statuses: JobStatuses): void;
+//# sourceMappingURL=k8s-job-waiter.d.ts.map

package/dist/libs/k8s-job-waiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-job-waiter.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-job-waiter.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,WAAW,GAAG,MAAM,CAC9B,MAAM,EACN;IAAE,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAC/E,CAAC;AAqEF,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EAAE,wBAKf;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,WAAW,QAmCrD"}

package/dist/libs/k8s-job-waiter.js

@@ -0,0 +1,84 @@
+import { CommandExecutor } from "../cli/common";
+import { envToNamespace } from "./k8s-constants";
+import { kubectlCommand } from "./k8s-helpers";
+const POLL_INTERVAL_SEC = 1;
+class K8sJobWaiter {
+    monorepoEnv;
+    timeoutInMs;
+    namespace;
+    jobStatuses;
+    constructor(monorepoEnv, timeoutInS) {
+        this.monorepoEnv = monorepoEnv;
+        this.namespace = envToNamespace(monorepoEnv);
+        this.jobStatuses = {};
+        this.timeoutInMs = timeoutInS * 1000;
+    }
+    async pollJob(job) {
+        const startTime = Date.now();
+        while (true) {
+            const res = await this.fetchStatus(job);
+            const elapsed = Date.now() - startTime;
+            if (res.failure > 0) {
+                const error = await this.fetchError(job);
+                this.jobStatuses[job] = { status: "failure", elapsed, error };
+                return;
+            }
+            if (res.success > 0) {
+                this.jobStatuses[job] = { status: "success", elapsed };
+                return;
+            }
+            if (elapsed >= this.timeoutInMs) {
+                this.jobStatuses[job] = { status: "timeout", elapsed };
+                return;
+            }
+            await new Promise((res) => setTimeout(res, POLL_INTERVAL_SEC * 1000));
+        }
+    }
+    async fetchStatus(job) {
+        const result = new CommandExecutor(kubectlCommand(`get job ${job} -o jsonpath='{.status.failed},{.status.succeeded}'`, { namespace: this.namespace })).exec();
+        const [failure, success] = result.split(",").map((x) => Number(x));
+        return { failure, success };
+    }
+    async fetchError(job) {
+        try {
+            const podName = new CommandExecutor(kubectlCommand(`get pod -l job-name=${job} -o name`, {
+                namespace: this.namespace,
+            })).exec();
+            const logs = new CommandExecutor(kubectlCommand(`logs ${podName}`, { namespace: this.namespace })).exec();
+            return logs;
+        }
+        catch (e) {
+            console.log("Error fetching logs for job", { job, e });
+            return `<COULD NOT FETCH ERROR FOR ${job}>`;
+        }
+    }
+}
+export async function k8sJobWaiter(monorepoEnv, timeoutInS, jobs) {
+    const waiter = new K8sJobWaiter(monorepoEnv, timeoutInS);
+    await Promise.all(jobs.map((job) => waiter.pollJob(job)));
+    return waiter.jobStatuses;
+}
+export function printJobStatuses(statuses) {
+    console.log("Statuses:");
+    Object.entries(statuses).forEach(([job, statusRecord]) => {
+        console.log(`${job}: ${statusRecord.status} ${Math.round((statusRecord.elapsed / 1000) * 100) / 100}s`);
+    });
+    console.log();
+    Object.entries(statuses)
+        .filter(([_, statusRecord]) => statusRecord.status === "failure")
+        .forEach(([job, statusRecord]) => {
+        console.error(`Error for ${job}:`);
+        console.error(statusRecord.error);
+        console.error();
+    });
+    const failures = Object.entries(statuses).filter(([_, statusRecord]) => ["failure", "timeout"].includes(statusRecord.status));
+    if (failures.length > 0) {
+        console.error();
+        console.error(`Some jobs did not succeed: ${failures.map(([job, _]) => job).join(", ")}`);
+        console.error();
+        process.exit(1);
+    }
+    Object.entries(statuses).forEach(([job, statusRecord]) => {
+        console.log(`${job}: ${statusRecord.status}`);
+    });
+}

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

@@ -0,0 +1,7 @@
+export declare const BASE_SECRET_KEY = "baseSecret";
+export declare function checkEnvSetup(monorepoEnv: string): boolean;
+export declare function createNamespace(monorepoEnv: string): void;
+export declare function createEmptyEnvSecret(monorepoEnv: string): void;
+export declare function patchBaseSecret(monorepoEnv: string): void;
+export declare function deleteNamespace(monorepoEnv: string): void;
+//# sourceMappingURL=k8s-namespace.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-namespace.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-namespace.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,eAAe,eAAe,CAAC;AAE5C,wBAAgB,aAAa,CAAC,WAAW,EAAE,MAAM,WAQhD;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,QAElD;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,QAGvD;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,QAQlD;AAED,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,QAGlD"}

package/dist/libs/k8s-namespace.js

@@ -0,0 +1,27 @@
+import { CommandExecutor } from "../cli/common";
+import { envToNamespace, secretName } from "./k8s-constants";
+import { kubectlCommand, patchSecretKeyCommand } from "./k8s-helpers";
+import { randomBytes } from "crypto";
+export const BASE_SECRET_KEY = 'baseSecret';
+export function checkEnvSetup(monorepoEnv) {
+    const namespace = envToNamespace(monorepoEnv);
+    const exitCode = new CommandExecutor(kubectlCommand(`get ns ${namespace}`)).exec({
+        onlyStatusCode: true,
+    });
+    return exitCode === 0;
+}
+export function createNamespace(monorepoEnv) {
+    new CommandExecutor(kubectlCommand(`create ns ${envToNamespace(monorepoEnv)}`)).exec();
+}
+export function createEmptyEnvSecret(monorepoEnv) {
+    const cmd = kubectlCommand(`create secret generic ${secretName()}`, { namespace: envToNamespace(monorepoEnv) });
+    new CommandExecutor(cmd).exec();
+}
+export function patchBaseSecret(monorepoEnv) {
+    const { fullCommand, redactedCommand } = patchSecretKeyCommand(monorepoEnv, secretName(), BASE_SECRET_KEY, randomBytes(32).toString('hex'));
+    new CommandExecutor(fullCommand, { quiet: true, redactedCommand }).exec();
+}
+export function deleteNamespace(monorepoEnv) {
+    const cmd = kubectlCommand(`delete ns ${envToNamespace(monorepoEnv)}`);
+    new CommandExecutor(cmd).exec();
+}

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

@@ -0,0 +1,6 @@
+export declare function getRedisList(): string | null;
+export declare function getRedisPassword(namespace: string): {
+    password: string;
+} | null;
+export declare function establishRedisTunnel(namespace: string, port: string): void;
+//# sourceMappingURL=k8s-redis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-redis.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-redis.ts"],"names":[],"mappings":"AAGA,wBAAgB,YAAY,kBAK3B;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM;;SAajD;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,QAKnE"}

package/dist/libs/k8s-redis.js

@@ -0,0 +1,31 @@
+import { CommandExecutor } from "../cli/common";
+import { kubectlCommand } from "./k8s-helpers";
+export function getRedisList() {
+    const cmd = kubectlCommand(`get pods -l app.kubernetes.io/name=redis -A`);
+    const res = new CommandExecutor(cmd, { quiet: true }).exec();
+    if (!res)
+        return null;
+    return res;
+}
+export function getRedisPassword(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 password = atob(resJson["redis-password"]);
+        return { password };
+    }
+    catch {
+        return null;
+    }
+}
+export function establishRedisTunnel(namespace, port) {
+    const cmd = kubectlCommand(`port-forward svc/${namespace}-master ${port}:6379`, {
+        namespace,
+    });
+    new CommandExecutor(cmd).spawn();
+}

package/dist/libs/k8s-secrets-manager.d.ts

@@ -0,0 +1,5 @@
+export declare function getMonorepoSecret(monorepoEnv: string, keys?: string[]): string;
+/** E.g.: setMonorepoSecret('staging', ['KEY1=val1', 'KEY2=val2']) */
+export declare function setMonorepoSecret(monorepoEnv: string, pairs?: string[]): void;
+export declare function deleteMonorepoSecret(monorepoEnv: string, keys?: string[]): void;
+//# sourceMappingURL=k8s-secrets-manager.d.ts.map

package/dist/libs/k8s-secrets-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"k8s-secrets-manager.d.ts","sourceRoot":"","sources":["../../src/libs/k8s-secrets-manager.ts"],"names":[],"mappings":"AA0DA,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,UAKzE;AAED,qEAAqE;AACrE,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,GAAE,MAAM,EAAO,QAQ1E;AAED,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,QAE5E"}

package/dist/libs/k8s-secrets-manager.js

@@ -0,0 +1,61 @@
+import { CommandExecutor } from "../cli/common";
+import { secretName } from "./k8s-constants";
+import { kubectlCommand, patchSecretKeyCommand } from "./k8s-helpers";
+// This env file should not be used in local development
+const SECRET_FILE_NAME = "env_json";
+// Basic commands (L1)
+// Override the secret value with the new value
+function execUpdateSecret(monorepoEnv, secretValue) {
+    const { fullCommand, redactedCommand } = patchSecretKeyCommand(monorepoEnv, secretName(), SECRET_FILE_NAME, JSON.stringify(secretValue));
+    new CommandExecutor(fullCommand, { quiet: true, redactedCommand }).exec();
+}
+function getSecret(monorepoEnv, keys = []) {
+    // Dots in jsonpath can only be accessed with a \ prefix
+    const escapedSecretFileName = SECRET_FILE_NAME.replaceAll(".", "\\.");
+    // prettier-ignore
+    const cmd = kubectlCommand(`get secrets/${secretName()} -o jsonpath="{.data['${escapedSecretFileName}']}"`, { monorepoEnv });
+    const res = new CommandExecutor(cmd, { quiet: true }).exec();
+    if (!res)
+        return {};
+    const resJson = JSON.parse(atob(res));
+    if (!keys || keys.length === 0)
+        return resJson;
+    return Object.fromEntries(keys.filter((x) => resJson[x]).map((x) => [x, resJson[x]]));
+}
+// Combined commands (L2)
+function updateSecret(monorepoEnv, vars) {
+    if (!vars || Object.keys(vars).length === 0) {
+        console.error("Keys-value pairs to set must be provided, e.g. KEY1=val1 KEY2=val2");
+        process.exit(1);
+    }
+    const current = getSecret(monorepoEnv);
+    const newVars = { ...current, ...vars };
+    execUpdateSecret(monorepoEnv, newVars);
+}
+function deleteSecretKeys(monorepoEnv, keys = []) {
+    if (!keys || keys.length === 0) {
+        console.error("Keys to delete must be provided");
+        process.exit(1);
+    }
+    const secretValue = getSecret(monorepoEnv);
+    keys.forEach((key) => delete secretValue[key]);
+    execUpdateSecret(monorepoEnv, secretValue);
+}
+//= Interface (L3)
+export function getMonorepoSecret(monorepoEnv, keys = []) {
+    const value = getSecret(monorepoEnv, keys);
+    return Object.entries(value)
+        .map((pair) => pair.join("="))
+        .join("\n");
+}
+/** E.g.: setMonorepoSecret('staging', ['KEY1=val1', 'KEY2=val2']) */
+export function setMonorepoSecret(monorepoEnv, pairs = []) {
+    const pairsObj = Object.fromEntries(pairs.map((x) => {
+        const [key, ...values] = x.split("=");
+        return [key, values.join("=")];
+    }));
+    updateSecret(monorepoEnv, pairsObj);
+}
+export function deleteMonorepoSecret(monorepoEnv, keys = []) {
+    deleteSecretKeys(monorepoEnv, keys);
+}