@vaharoni/devops 1.0.47

package/dist/devops.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env bun
+// This file behaves as a façade for various devops scripts
+import { CLICommandParser, printUsageAndExit } from "./cli/common";
+import affected from "./cli/affected";
+import constant from "./cli/constant";
+import console from "./cli/console";
+import db from "./cli/db";
+import dml from "./cli/dml";
+import registry from "./cli/registry";
+import env from "./cli/env";
+import exec from "./cli/exec";
+import prepBuild from "./cli/prep-build";
+import prisma from "./cli/prisma";
+import run from "./cli/run";
+import runMany from "./cli/run-many";
+import test from "./cli/test";
+import init from "./cli/init";
+import redis from "./cli/redis";
+import internalCurl from "./cli/internal-curl";
+import jwt from "./cli/jwt";
+import namespace from "./cli/namespace";
+import image from "./cli/image";
+import template from "./cli/template";
+import job from "./cli/job";
+const [_node, _scriptPath, ...commandArgs] = process.argv;
+const allImports = [
+    // day-to-day
+    init,
+    run,
+    runMany,
+    exec,
+    env,
+    prisma,
+    dml,
+    db,
+    redis,
+    console,
+    test,
+    //= Infra
+    namespace,
+    image,
+    template,
+    job,
+    //= Deployment
+    prepBuild,
+    affected,
+    constant,
+    registry,
+    internalCurl,
+    jwt
+];
+const commands = {};
+allImports.forEach((imported) => {
+    Object.entries(imported).forEach(([key, object]) => {
+        const { oneLiner, keyExamples, run } = object;
+        commands[key] = { oneLiner, keyExamples, run, key };
+    });
+});
+const keyLength = Math.max(...Object.keys(commands).map((x) => x.length)) + 10;
+const newLine = "\n    ";
+const GENERAL_USAGE = `
+Devops utilities for the monorepo.
+
+USAGE
+    devops <command> <args> <env-options>
+
+CHOOSING ENV with <env-options>
+    By default, all commands run under the env specified in MONOREPO_ENV env variable, or development if it does not exist.
+    The test command is an exception: its environment is forced to test. 
+    When running in development, the env files config/.env.development and config/.env.global are injected, where the 
+    former overrides the latter.
+
+    To override the environment in which a command is executed in, use --env <some-env>. This overrides the MONOREPO_ENV variable.
+    You can use it anywhere in the command, i.e. the following are equivalent:
+    $ devops --env staging run project:task
+    $ devops run project:task --env staging
+
+    Supported environments: development, staging, test, and production.
+
+    Certain commands like run, exec, and prisma ensure that the env variables exist and correspond to env.yaml files in the repo. 
+    To skip this check, use --skip-env-check.
+
+
+COMMANDS
+    ${Object.values(commands)
+    .map((cmd) => [cmd.key, " ".repeat(keyLength - cmd.key.length), cmd.oneLiner].join(""))
+    .join(newLine)}
+`;
+// EXAMPLES
+//     ${Object.values(commands)
+//       .map((cmd) =>
+//         cmd.keyExamples
+//           .split("\n")
+//           .map((x) => x.trim())
+//           .filter(Boolean)
+//           .join(newLine)
+//       )
+//       .join(newLine)}
+const commandObj = new CLICommandParser(commandArgs);
+const chosenCommand = commands[commandObj.command];
+if (!chosenCommand)
+    printUsageAndExit(GENERAL_USAGE);
+chosenCommand.run(commandObj);

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types/index";
+export * from "./app-support/discovery/service-endpoint";
+export * from "./app-support/crypto";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,0CAA0C,CAAC;AACzD,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./types/index";
+export * from "./app-support/discovery/service-endpoint";
+export * from "./app-support/crypto";

package/dist/libs/affected-entities.d.ts

@@ -0,0 +1,15 @@
+type AffectedOpts = {
+    baseSha?: string;
+    headSha?: string;
+    fromLiveVersion?: boolean;
+    monorepoEnv?: string;
+};
+export declare function isImageAffected(image: string, opts?: AffectedOpts): boolean;
+export declare function findImagesAffected(opts?: AffectedOpts): string[];
+export declare function isWorkspaceAffected(workspaceName: string, opts?: {
+    baseSha?: string;
+    headSha?: string;
+}): boolean;
+export declare function findImagesWithAffectedWorkspace(workspaceName: string, opts?: AffectedOpts): string[];
+export {};
+//# sourceMappingURL=affected-entities.d.ts.map

package/dist/libs/affected-entities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affected-entities.d.ts","sourceRoot":"","sources":["../../src/libs/affected-entities.ts"],"names":[],"mappings":"AAMA,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,YAAiB,WAoBrE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,YAAiB,YAIzD;AAED,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,MAAM,EACrB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,WAIlD;AAED,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,MAAM,EACrB,IAAI,GAAE,YAAiB,YAmBxB"}

package/dist/libs/affected-entities.js

@@ -0,0 +1,52 @@
+import { getImageNames } from "./config";
+import { getWorkspace } from "./discovery";
+import { getImageDescendentData, getWorkspaceImages } from "./discovery/images";
+import { commitExists, isAffected } from "./git-helpers";
+import { getImageVersion } from "./k8s-image-config";
+export function isImageAffected(image, opts = {}) {
+    const headSha = opts.headSha ?? "HEAD";
+    let baseSha;
+    if (opts.fromLiveVersion) {
+        if (!opts.monorepoEnv) {
+            throw new Error("monorepoEnv is required when fromLiveVersion is true");
+        }
+        baseSha = getImageVersion(opts.monorepoEnv, image);
+        if (!baseSha)
+            return true;
+    }
+    baseSha ??= opts.baseSha ?? "HEAD^";
+    const descendentData = getImageDescendentData(image);
+    if (!commitExists(baseSha) || !commitExists(headSha))
+        return true;
+    for (const { rootPath } of descendentData) {
+        if (isAffected(rootPath, { baseSha, headSha, skipCheck: true })) {
+            return true;
+        }
+    }
+    return false;
+}
+export function findImagesAffected(opts = {}) {
+    return getImageNames().filter((imageName) => isImageAffected(imageName, opts));
+}
+export function isWorkspaceAffected(workspaceName, opts = {}) {
+    const data = getWorkspace(workspaceName);
+    return isAffected(data.rootPath, opts);
+}
+export function findImagesWithAffectedWorkspace(workspaceName, opts = {}) {
+    const res = [];
+    const headSha = opts.headSha ?? "HEAD";
+    const defaultBaseSha = opts.baseSha ?? "HEAD^";
+    const rootPath = getWorkspace(workspaceName).rootPath;
+    if (opts.fromLiveVersion && !opts.monorepoEnv) {
+        throw new Error("monorepoEnv is required when fromLiveVersion is true");
+    }
+    for (const imageName of getWorkspaceImages(workspaceName)) {
+        const baseSha = opts.fromLiveVersion
+            ? getImageVersion(opts.monorepoEnv, imageName)
+            : defaultBaseSha;
+        if (isAffected(rootPath, { baseSha, headSha })) {
+            res.push(imageName);
+        }
+    }
+    return res;
+}

package/dist/libs/config.d.ts

@@ -0,0 +1,6 @@
+import { type ConstFileSchema, type SingleImageSchema, type SingleTemplateSchema } from "../types";
+export declare const getConst: <T extends keyof ConstFileSchema>(key: T, opts?: {
+    ignoreIfInvalid?: boolean;
+}) => ConstFileSchema[T] | undefined;
+export declare const getImageData: (imageName: string) => SingleImageSchema, getImageNames: () => string[], getTemplateData: (templateName: string) => SingleTemplateSchema;
+//# sourceMappingURL=config.d.ts.map

package/dist/libs/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/libs/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAoC,KAAK,eAAe,EAAwB,KAAK,iBAAiB,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAM3J,eAAO,MAAQ,QAAQ,GA2BH,CAAC,SAAS,MAAM,eAAe,OAAO,CAAC,SAAQ;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,KAAQ,eAAe,CAAC,CAAC,CAAC,GAAG,SAAS,AA3BxF,CAAC;AAC/C,eAAO,MAAQ,YAAY,cAkEQ,MAAM,KAAG,iBAAiB,EAlEhC,aAAa,kBAAE,eAAe,iBAwFlB,MAAM,KAAG,oBAAoB,AAxFa,CAAC"}

package/dist/libs/config.js

@@ -0,0 +1,98 @@
+import { readFileSync } from "fs";
+import yaml from "yaml";
+import path from "path";
+import { getWorkspace } from "./discovery";
+import { constFileSchema, imageFileSchema } from "../types";
+const constantsFilePath = path.join(process.cwd(), ".devops/config/constants.yaml");
+const imagesFilePath = path.join(process.cwd(), ".devops/config/images.yaml");
+// We want these to be lazy loaded so that calling devops in a context that does not need the config files won't fail
+export const { getConst } = processConstFile();
+export const { getImageData, getImageNames, getTemplateData } = processImagesFile();
+// Process config/constants.yaml
+function processConstFile() {
+    let constants;
+    function constFileData() {
+        if (constants)
+            return constants;
+        try {
+            const constantsYaml = readFileSync(constantsFilePath, "utf8");
+            constants = yaml.parse(constantsYaml);
+        }
+        catch (e) {
+            // This is only a warning - the file may not exist, which is fine if getConst is called with ignoreIfInvalid
+            console.warn("Warning: cannot read .devops/config/constants.yaml");
+            return { valid: false };
+        }
+        const parseRes = constFileSchema.safeParse(constants);
+        if (parseRes.error) {
+            // This is an error - if the file exists, it must be valid
+            console.error(`Error parsing config/constants.yaml: ${parseRes.error.toString()}`);
+            process.exit(1);
+        }
+        constants = { valid: true, data: parseRes.data };
+        return constants;
+    }
+    function getConst(key, opts = {}) {
+        const { valid, data } = constFileData();
+        if (!valid && !opts.ignoreIfInvalid) {
+            console.error(".devops/config/constants.yaml is invalid");
+            process.exit(1);
+        }
+        const value = data?.[key];
+        if (!value && !opts.ignoreIfInvalid) {
+            console.error(`Missing constant in .devops/config/constants.yaml: ${key}`);
+            process.exit(1);
+        }
+        return value;
+    }
+    return { getConst };
+}
+// Process config/images.yaml
+function processImagesFile() {
+    let images;
+    function imagesFileData() {
+        if (images)
+            return images;
+        try {
+            const imagesYaml = readFileSync(imagesFilePath, "utf8");
+            images = yaml.parse(imagesYaml);
+        }
+        catch (e) {
+            console.error("Error reading .devops/config/images.yaml");
+            process.exit(1);
+        }
+        const parseRes = imageFileSchema.safeParse(images);
+        if (parseRes.error) {
+            console.error(`Error parsing config/images.yaml: ${parseRes.error.toString()}`);
+            process.exit(1);
+        }
+        return images;
+    }
+    function getImageData(imageName) {
+        const imageData = imagesFileData()['images'][imageName];
+        if (!imageData) {
+            console.error(`Image ${imageName} not found in .devops/config/images.yaml`);
+            process.exit(1);
+        }
+        imageData.applications.forEach((project) => {
+            const data = getWorkspace(project);
+            if (!data) {
+                console.error(`Project ${project} not found for image ${imageName} in .devops/config/images.yaml`);
+                process.exit(1);
+            }
+        });
+        return imageData;
+    }
+    function getTemplateData(templateName) {
+        const templateData = imagesFileData()['templates'][templateName];
+        if (!templateData) {
+            console.error(`Template ${templateName} not found in .devops/config/images.yaml`);
+            process.exit(1);
+        }
+        return templateData;
+    }
+    function getImageNames() {
+        return Object.keys(imagesFileData()["images"]);
+    }
+    return { getImageData, getImageNames, getTemplateData };
+}

package/dist/libs/dependencies.d.ts

@@ -0,0 +1,19 @@
+import type { ProjectData } from "../types";
+export declare class WorkspaceDependencies {
+    getAllProjects: () => Record<string, ProjectData>;
+    dependencies: Record<string, DependencyNode>;
+    loaded: boolean;
+    projects: Record<string, ProjectData>;
+    constructor(getAllProjects: () => Record<string, ProjectData>);
+    _getOrCreate(name: string): DependencyNode;
+    _buildTree(): void;
+    getDependents(workspaceName: string): string[];
+}
+declare class DependencyNode {
+    name: string;
+    dependsOn: Set<string>;
+    constructor(name: string);
+    flattenDependents(allDependencies: Record<string, DependencyNode>, visited?: Set<string>): string[];
+}
+export {};
+//# sourceMappingURL=dependencies.d.ts.map

package/dist/libs/dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.d.ts","sourceRoot":"","sources":["../../src/libs/dependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5C,qBAAa,qBAAqB;IAKb,cAAc,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IAJpE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAM;IAClD,MAAM,UAAS;IACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAM;gBAExB,cAAc,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IAEpE,YAAY,CAAC,IAAI,EAAE,MAAM;IASzB,UAAU;IAcV,aAAa,CAAC,aAAa,EAAE,MAAM;CAWpC;AAED,cAAM,cAAc;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;gBAEX,IAAI,EAAE,MAAM;IAKxB,iBAAiB,CACf,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAC/C,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;CAexB"}

package/dist/libs/dependencies.js

@@ -0,0 +1,62 @@
+import chalk from "chalk";
+export class WorkspaceDependencies {
+    getAllProjects;
+    dependencies = {};
+    loaded = false;
+    projects = {};
+    constructor(getAllProjects) {
+        this.getAllProjects = getAllProjects;
+    }
+    _getOrCreate(name) {
+        let node = this.dependencies[name];
+        if (!node) {
+            node = new DependencyNode(name);
+            this.dependencies[name] = node;
+        }
+        return node;
+    }
+    _buildTree() {
+        this.projects = this.getAllProjects();
+        this.loaded = true;
+        for (const workspace of Object.keys(this.projects)) {
+            const node = this._getOrCreate(workspace);
+            const { data } = this.projects[workspace];
+            for (const dep of data.dependencyNames ?? []) {
+                if (this.projects[dep]) {
+                    node.dependsOn.add(dep);
+                }
+            }
+        }
+    }
+    getDependents(workspaceName) {
+        if (!this.loaded) {
+            this._buildTree();
+        }
+        const node = this.dependencies[workspaceName];
+        if (!node) {
+            console.error(chalk.red(`\nWorkspace ${workspaceName} not found\n`));
+            process.exit(1);
+        }
+        return node.flattenDependents(this.dependencies);
+    }
+}
+class DependencyNode {
+    name;
+    dependsOn;
+    constructor(name) {
+        this.name = name;
+        this.dependsOn = new Set();
+    }
+    flattenDependents(allDependencies, visited) {
+        visited ??= new Set();
+        visited.add(this.name);
+        const notVisitedDependents = [];
+        for (const dep of this.dependsOn) {
+            if (!visited.has(dep)) {
+                const node = allDependencies[dep];
+                notVisitedDependents.push(...node.flattenDependents(allDependencies, visited));
+            }
+        }
+        return [this.name, ...notVisitedDependents];
+    }
+}

package/dist/libs/dependencies.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dependencies.spec.d.ts.map

package/dist/libs/dependencies.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.spec.d.ts","sourceRoot":"","sources":["../../src/libs/dependencies.spec.ts"],"names":[],"mappings":""}

package/dist/libs/dependencies.spec.js

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { WorkspaceDependencies } from './dependencies';
+describe('createDependencyResolver', () => {
+    const projects = {
+        '@local/a': { rootPath: 'applications/a', data: { name: '@local/a', dependencies: { '@local/b': 'workspace:*', '@local/d': 'workspace:*', external1: "^1.0.0" } } },
+        '@local/b': { rootPath: 'applications/b', data: { name: '@local/b', dependencies: { '@local/c': 'workspace:*', external2: "^1.0.0" } } },
+        '@local/c': { rootPath: 'applications/c', data: { name: '@local/c', dependencies: { external3: "^1.0.0" } } },
+        '@local/d': { rootPath: 'applications/d', data: { name: '@local/d' } },
+        '@local/e': { rootPath: 'applications/e', data: { name: '@local/e', dependencies: { '@local/f': 'workspace:*' } } },
+        '@local/f': { rootPath: 'applications/f', data: { name: '@local/f', dependencies: { '@local/e': 'workspace:*' } } },
+    };
+    it('should return dependents of a given project', () => {
+        const resolver = new WorkspaceDependencies(() => projects);
+        expect(resolver.getDependents('@local/a')).toEqual(['@local/a', '@local/b', '@local/c', '@local/d']);
+        expect(resolver.getDependents('@local/b')).toEqual(['@local/b', '@local/c']);
+        expect(resolver.getDependents('@local/c')).toEqual(['@local/c']);
+        expect(resolver.getDependents('@local/d')).toEqual(['@local/d']);
+        expect(resolver.getDependents('@local/e')).toEqual(['@local/e', '@local/f']);
+        expect(resolver.getDependents('@local/f')).toEqual(['@local/f', '@local/e']);
+    });
+});

package/dist/libs/digital-ocean/container-reg.d.ts

@@ -0,0 +1,6 @@
+export declare function prune(
+/** To keep the image-related constants simple, this accepts the full URL including the prefix registry.digitalocean.com */
+registryFullName: string, 
+/** The name of the repository inside the registry */
+repoName: string): void;
+//# sourceMappingURL=container-reg.d.ts.map

package/dist/libs/digital-ocean/container-reg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container-reg.d.ts","sourceRoot":"","sources":["../../../src/libs/digital-ocean/container-reg.ts"],"names":[],"mappings":"AA0DA,wBAAgB,KAAK;AACnB,2HAA2H;AAC3H,gBAAgB,EAAE,MAAM;AACxB,qDAAqD;AACrD,QAAQ,EAAE,MAAM,QAkBjB"}

package/dist/libs/digital-ocean/container-reg.js

@@ -0,0 +1,69 @@
+import { CommandExecutor } from "../../cli/common";
+import { z } from "zod";
+import { getConst } from "../config";
+const repoTagMetadataSchema = z.object({
+    // What we rely on
+    tag: z.string().optional(),
+    updated_at: z.string(),
+    manifest_digest: z.string(),
+    // Other fields that existed in the output
+    // registry_name: z.string().optional(),
+    // repository: z.string().optional(),
+    // compressed_size_bytes: z.number().optional(),
+    // size_bytes: z.number().optional(),
+});
+const repoTagMetadataSchemaOutput = z.array(repoTagMetadataSchema);
+/** The metadata is returned in descending order (most recent first) */
+function getRepoTagMetadata(repoName) {
+    // Get the metadata for the tags in the repository
+    const cmd = `doctl registry repository list-tags ${repoName} -o json`;
+    const res = new CommandExecutor(cmd, { quiet: true }).exec();
+    if (!res)
+        return [];
+    try {
+        const parsed = JSON.parse(res);
+        const parseRes = repoTagMetadataSchemaOutput.safeParse(parsed);
+        if (parseRes.error) {
+            console.error(`Error schema-parsing output from "${cmd}": ${parseRes.error.toString()}`);
+            console.error(">>> Command output");
+            console.error(res);
+            process.exit(1);
+        }
+        return parseRes.data
+            .filter((data) => data.tag)
+            .sort((a, b) => new Date(b.updated_at).getTime() - new Date(a.updated_at).getTime());
+    }
+    catch (e) {
+        console.error(`Error JSON-parsing output from "${cmd}": ${res}`);
+        process.exit(1);
+    }
+}
+function deleteRepoTag(repoName, tag) {
+    const cmd = `doctl registry repository delete-tag ${repoName} ${tag} --force`;
+    new CommandExecutor(cmd).exec();
+}
+function stargGarbageCollection(registryName) {
+    const cmd = `doctl registry garbage-collection start --include-untagged-manifests ${registryName} --force`;
+    new CommandExecutor(cmd).exec();
+}
+export function prune(
+/** To keep the image-related constants simple, this accepts the full URL including the prefix registry.digitalocean.com */
+registryFullName, 
+/** The name of the repository inside the registry */
+repoName) {
+    const infra = getConst("infra");
+    if (infra !== "digitalocean") {
+        console.warn("Pruning is only supported for the DigitalOcean container registry");
+        return;
+    }
+    const tags = getRepoTagMetadata(repoName);
+    const versionsToKeep = Number(getConst("image-versions-to-keep"));
+    if (!tags.length || tags.length <= versionsToKeep)
+        return;
+    const tagsToDelete = tags.slice(versionsToKeep);
+    tagsToDelete.forEach((tag) => {
+        deleteRepoTag(repoName, tag.tag);
+    });
+    const registryName = registryFullName.split("/").slice(-1)[0];
+    stargGarbageCollection(registryName);
+}

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

@@ -0,0 +1,19 @@
+import type { PackageData } from "../../types";
+export declare class WorkspaceDependencies {
+    getAllProjects: () => Record<string, PackageData>;
+    dependencies: Record<string, DependencyNode>;
+    loaded: boolean;
+    workspaces: Record<string, PackageData>;
+    constructor(getAllProjects: () => Record<string, PackageData>);
+    _getOrCreate(name: string): DependencyNode;
+    _buildTree(): void;
+    getDependents(workspaceName: string): string[];
+}
+declare class DependencyNode {
+    name: string;
+    dependsOn: Set<string>;
+    constructor(name: string);
+    flattenDependents(allDependencies: Record<string, DependencyNode>, visited?: Set<string>): string[];
+}
+export {};
+//# sourceMappingURL=dependencies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/dependencies.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,qBAAa,qBAAqB;IAKb,cAAc,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IAJpE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAAM;IAClD,MAAM,UAAS;IACf,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAM;gBAE1B,cAAc,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;IAEpE,YAAY,CAAC,IAAI,EAAE,MAAM;IASzB,UAAU;IAcV,aAAa,CAAC,aAAa,EAAE,MAAM;CAWpC;AAED,cAAM,cAAc;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;gBAEX,IAAI,EAAE,MAAM;IAKxB,iBAAiB,CACf,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,EAC/C,OAAO,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;CAexB"}

package/dist/libs/discovery/dependencies.js

@@ -0,0 +1,62 @@
+import chalk from "chalk";
+export class WorkspaceDependencies {
+    getAllProjects;
+    dependencies = {};
+    loaded = false;
+    workspaces = {};
+    constructor(getAllProjects) {
+        this.getAllProjects = getAllProjects;
+    }
+    _getOrCreate(name) {
+        let node = this.dependencies[name];
+        if (!node) {
+            node = new DependencyNode(name);
+            this.dependencies[name] = node;
+        }
+        return node;
+    }
+    _buildTree() {
+        this.workspaces = this.getAllProjects();
+        this.loaded = true;
+        for (const workspace of Object.keys(this.workspaces)) {
+            const node = this._getOrCreate(workspace);
+            const data = this.workspaces[workspace];
+            for (const dep of data.dependencyNames ?? []) {
+                if (this.workspaces[dep]) {
+                    node.dependsOn.add(dep);
+                }
+            }
+        }
+    }
+    getDependents(workspaceName) {
+        if (!this.loaded) {
+            this._buildTree();
+        }
+        const node = this.dependencies[workspaceName];
+        if (!node) {
+            console.error(chalk.red(`\nWorkspace ${workspaceName} not found\n`));
+            process.exit(1);
+        }
+        return node.flattenDependents(this.dependencies);
+    }
+}
+class DependencyNode {
+    name;
+    dependsOn;
+    constructor(name) {
+        this.name = name;
+        this.dependsOn = new Set();
+    }
+    flattenDependents(allDependencies, visited) {
+        visited ??= new Set();
+        visited.add(this.name);
+        const notVisitedDependents = [];
+        for (const dep of this.dependsOn) {
+            if (!visited.has(dep)) {
+                const node = allDependencies[dep];
+                notVisitedDependents.push(...node.flattenDependents(allDependencies, visited));
+            }
+        }
+        return [this.name, ...notVisitedDependents];
+    }
+}

package/dist/libs/discovery/dependencies.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=dependencies.spec.d.ts.map

package/dist/libs/discovery/dependencies.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependencies.spec.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/dependencies.spec.ts"],"names":[],"mappings":""}

package/dist/libs/discovery/dependencies.spec.js

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import { WorkspaceDependencies } from './dependencies';
+describe('createDependencyResolver', () => {
+    const projects = {
+        '@local/a': { language: "node", rootPath: 'applications/a', name: '@local/a', dependencyNames: ['@local/b', '@local/d', 'external1'] },
+        '@local/b': { language: "node", rootPath: 'applications/b', name: '@local/b', dependencyNames: ['@local/c', 'external2'] },
+        '@local/c': { language: "node", rootPath: 'applications/c', name: '@local/c', dependencyNames: ['external3'] },
+        '@local/d': { language: "node", rootPath: 'applications/d', name: '@local/d', dependencyNames: [] },
+        '@local/e': { language: "node", rootPath: 'applications/e', name: '@local/e', dependencyNames: ['@local/f'] },
+        '@local/f': { language: "node", rootPath: 'applications/f', name: '@local/f', dependencyNames: ['@local/e'] }
+    };
+    it('should return dependents of a given project', () => {
+        const resolver = new WorkspaceDependencies(() => projects);
+        expect(resolver.getDependents('@local/a')).toEqual(['@local/a', '@local/b', '@local/c', '@local/d']);
+        expect(resolver.getDependents('@local/b')).toEqual(['@local/b', '@local/c']);
+        expect(resolver.getDependents('@local/c')).toEqual(['@local/c']);
+        expect(resolver.getDependents('@local/d')).toEqual(['@local/d']);
+        expect(resolver.getDependents('@local/e')).toEqual(['@local/e', '@local/f']);
+        expect(resolver.getDependents('@local/f')).toEqual(['@local/f', '@local/e']);
+    });
+});

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

@@ -0,0 +1,5 @@
+import type { PackageData } from "../../types";
+/** The dependent workspaces are specified in config/images.yaml */
+export declare function getImageDescendentData(imageName: string): PackageData[];
+export declare function getWorkspaceImages(workspaceName: string): string[];
+//# sourceMappingURL=images.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"images.d.ts","sourceRoot":"","sources":["../../../src/libs/discovery/images.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AA0B/C,mEAAmE;AACnE,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,iBAIvD;AAqBD,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,YAGvD"}